mflodman@webrtc.org | e6168f5 | 2013-06-26 11:23:01 +0000 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (c) 2013 The WebRTC project authors. All Rights Reserved. |
| 3 | * |
| 4 | * Use of this source code is governed by a BSD-style license |
| 5 | * that can be found in the LICENSE file in the root of the source |
| 6 | * tree. An additional intellectual property rights grant can be found |
| 7 | * in the file PATENTS. All contributing project authors may |
| 8 | * be found in the AUTHORS file in the root of the source tree. |
| 9 | */ |
| 10 | |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 11 | #include "video/overuse_frame_detector.h" |
mflodman@webrtc.org | e6168f5 | 2013-06-26 11:23:01 +0000 | [diff] [blame] | 12 | |
pbos@webrtc.org | a957570 | 2013-08-30 17:16:32 +0000 | [diff] [blame] | 13 | #include <math.h> |
Piotr Tworek | 5e4833c | 2017-12-12 12:09:31 +0100 | [diff] [blame] | 14 | #include <stdio.h> |
mflodman@webrtc.org | d4412fe | 2013-07-31 16:42:21 +0000 | [diff] [blame] | 15 | |
asapersson@webrtc.org | 9e5b034 | 2013-12-04 13:47:44 +0000 | [diff] [blame] | 16 | #include <algorithm> |
| 17 | #include <list> |
asapersson@webrtc.org | 734a532 | 2014-06-10 06:35:22 +0000 | [diff] [blame] | 18 | #include <map> |
Mirko Bonadei | 317a1f0 | 2019-09-17 17:06:18 +0200 | [diff] [blame] | 19 | #include <memory> |
sprang | c5d62e2 | 2017-04-02 23:53:04 -0700 | [diff] [blame] | 20 | #include <string> |
| 21 | #include <utility> |
asapersson@webrtc.org | 9e5b034 | 2013-12-04 13:47:44 +0000 | [diff] [blame] | 22 | |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 23 | #include "api/video/video_frame.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 24 | #include "rtc_base/checks.h" |
| 25 | #include "rtc_base/logging.h" |
Niels Möller | 7dc26b7 | 2017-12-06 10:27:48 +0100 | [diff] [blame] | 26 | #include "rtc_base/numerics/exp_filter.h" |
Steve Anton | 10542f2 | 2019-01-11 09:11:00 -0800 | [diff] [blame] | 27 | #include "rtc_base/time_utils.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 28 | #include "system_wrappers/include/field_trial.h" |
mflodman@webrtc.org | e6168f5 | 2013-06-26 11:23:01 +0000 | [diff] [blame] | 29 | |
pbos | a102507 | 2016-05-14 03:04:19 -0700 | [diff] [blame] | 30 | #if defined(WEBRTC_MAC) && !defined(WEBRTC_IOS) |
torbjorng | 448468d | 2016-02-10 08:11:57 -0800 | [diff] [blame] | 31 | #include <mach/mach.h> |
pbos | a102507 | 2016-05-14 03:04:19 -0700 | [diff] [blame] | 32 | #endif // defined(WEBRTC_MAC) && !defined(WEBRTC_IOS) |
torbjorng | 448468d | 2016-02-10 08:11:57 -0800 | [diff] [blame] | 33 | |
mflodman@webrtc.org | e6168f5 | 2013-06-26 11:23:01 +0000 | [diff] [blame] | 34 | namespace webrtc { |
| 35 | |
mflodman@webrtc.org | d4412fe | 2013-07-31 16:42:21 +0000 | [diff] [blame] | 36 | namespace { |
perkj | d52063f | 2016-09-07 06:32:18 -0700 | [diff] [blame] | 37 | const int64_t kCheckForOveruseIntervalMs = 5000; |
| 38 | const int64_t kTimeToFirstCheckForOveruseMs = 100; |
mflodman@webrtc.org | d4412fe | 2013-07-31 16:42:21 +0000 | [diff] [blame] | 39 | |
pbos@webrtc.org | a957570 | 2013-08-30 17:16:32 +0000 | [diff] [blame] | 40 | // Delay between consecutive rampups. (Used for quick recovery.) |
| 41 | const int kQuickRampUpDelayMs = 10 * 1000; |
| 42 | // Delay between rampup attempts. Initially uses standard, scales up to max. |
asapersson@webrtc.org | 23a4d85 | 2014-08-13 14:33:49 +0000 | [diff] [blame] | 43 | const int kStandardRampUpDelayMs = 40 * 1000; |
asapersson@webrtc.org | 2881ab1 | 2014-06-12 08:46:46 +0000 | [diff] [blame] | 44 | const int kMaxRampUpDelayMs = 240 * 1000; |
pbos@webrtc.org | a957570 | 2013-08-30 17:16:32 +0000 | [diff] [blame] | 45 | // Expontential back-off factor, to prevent annoying up-down behaviour. |
| 46 | const double kRampUpBackoffFactor = 2.0; |
mflodman@webrtc.org | d4412fe | 2013-07-31 16:42:21 +0000 | [diff] [blame] | 47 | |
asapersson@webrtc.org | d980307 | 2014-06-16 14:27:19 +0000 | [diff] [blame] | 48 | // Max number of overuses detected before always applying the rampup delay. |
asapersson@webrtc.org | 23a4d85 | 2014-08-13 14:33:49 +0000 | [diff] [blame] | 49 | const int kMaxOverusesBeforeApplyRampupDelay = 4; |
asapersson@webrtc.org | 9e5b034 | 2013-12-04 13:47:44 +0000 | [diff] [blame] | 50 | |
Niels Möller | 7dc26b7 | 2017-12-06 10:27:48 +0100 | [diff] [blame] | 51 | // The maximum exponent to use in VCMExpFilter. |
| 52 | const float kMaxExp = 7.0f; |
| 53 | // Default value used before first reconfiguration. |
| 54 | const int kDefaultFrameRate = 30; |
| 55 | // Default sample diff, default frame rate. |
| 56 | const float kDefaultSampleDiffMs = 1000.0f / kDefaultFrameRate; |
| 57 | // A factor applied to the sample diff on OnTargetFramerateUpdated to determine |
| 58 | // a max limit for the sample diff. For instance, with a framerate of 30fps, |
| 59 | // the sample diff is capped to (1000 / 30) * 1.35 = 45ms. This prevents |
| 60 | // triggering too soon if there are individual very large outliers. |
| 61 | const float kMaxSampleDiffMarginFactor = 1.35f; |
| 62 | // Minimum framerate allowed for usage calculation. This prevents crazy long |
| 63 | // encode times from being accepted if the frame rate happens to be low. |
| 64 | const int kMinFramerate = 7; |
| 65 | const int kMaxFramerate = 30; |
| 66 | |
sprang | b1ca073 | 2017-02-01 08:38:12 -0800 | [diff] [blame] | 67 | const auto kScaleReasonCpu = AdaptationObserverInterface::AdaptReason::kCpu; |
torbjorng | 448468d | 2016-02-10 08:11:57 -0800 | [diff] [blame] | 68 | |
asapersson@webrtc.org | 9aed002 | 2014-10-16 06:57:12 +0000 | [diff] [blame] | 69 | // Class for calculating the processing usage on the send-side (the average |
| 70 | // processing time of a frame divided by the average time difference between |
| 71 | // captured frames). |
Niels Möller | 83dbeac | 2017-12-14 16:39:44 +0100 | [diff] [blame] | 72 | class SendProcessingUsage1 : public OveruseFrameDetector::ProcessingUsage { |
asapersson@webrtc.org | 9e5b034 | 2013-12-04 13:47:44 +0000 | [diff] [blame] | 73 | public: |
Niels Möller | 83dbeac | 2017-12-14 16:39:44 +0100 | [diff] [blame] | 74 | explicit SendProcessingUsage1(const CpuOveruseOptions& options) |
Niels Möller | 7dc26b7 | 2017-12-06 10:27:48 +0100 | [diff] [blame] | 75 | : kWeightFactorFrameDiff(0.998f), |
| 76 | kWeightFactorProcessing(0.995f), |
| 77 | kInitialSampleDiffMs(40.0f), |
Niels Möller | 7dc26b7 | 2017-12-06 10:27:48 +0100 | [diff] [blame] | 78 | options_(options), |
Niels Möller | e08cf3a | 2017-12-07 15:23:58 +0100 | [diff] [blame] | 79 | count_(0), |
| 80 | last_processed_capture_time_us_(-1), |
Niels Möller | 7dc26b7 | 2017-12-06 10:27:48 +0100 | [diff] [blame] | 81 | max_sample_diff_ms_(kDefaultSampleDiffMs * kMaxSampleDiffMarginFactor), |
| 82 | filtered_processing_ms_(new rtc::ExpFilter(kWeightFactorProcessing)), |
| 83 | filtered_frame_diff_ms_(new rtc::ExpFilter(kWeightFactorFrameDiff)) { |
asapersson@webrtc.org | ce12f1f | 2014-03-24 21:59:16 +0000 | [diff] [blame] | 84 | Reset(); |
asapersson@webrtc.org | 9e5b034 | 2013-12-04 13:47:44 +0000 | [diff] [blame] | 85 | } |
Mirko Bonadei | fe055c1 | 2019-01-29 22:53:28 +0100 | [diff] [blame] | 86 | ~SendProcessingUsage1() override {} |
asapersson@webrtc.org | 9e5b034 | 2013-12-04 13:47:44 +0000 | [diff] [blame] | 87 | |
Niels Möller | 904f869 | 2017-12-07 11:22:39 +0100 | [diff] [blame] | 88 | void Reset() override { |
Niels Möller | e08cf3a | 2017-12-07 15:23:58 +0100 | [diff] [blame] | 89 | frame_timing_.clear(); |
Niels Möller | 7dc26b7 | 2017-12-06 10:27:48 +0100 | [diff] [blame] | 90 | count_ = 0; |
Niels Möller | e08cf3a | 2017-12-07 15:23:58 +0100 | [diff] [blame] | 91 | last_processed_capture_time_us_ = -1; |
Niels Möller | 7dc26b7 | 2017-12-06 10:27:48 +0100 | [diff] [blame] | 92 | max_sample_diff_ms_ = kDefaultSampleDiffMs * kMaxSampleDiffMarginFactor; |
| 93 | filtered_frame_diff_ms_->Reset(kWeightFactorFrameDiff); |
| 94 | filtered_frame_diff_ms_->Apply(1.0f, kInitialSampleDiffMs); |
| 95 | filtered_processing_ms_->Reset(kWeightFactorProcessing); |
| 96 | filtered_processing_ms_->Apply(1.0f, InitialProcessingMs()); |
asapersson@webrtc.org | ce12f1f | 2014-03-24 21:59:16 +0000 | [diff] [blame] | 97 | } |
| 98 | |
Niels Möller | 904f869 | 2017-12-07 11:22:39 +0100 | [diff] [blame] | 99 | void SetMaxSampleDiffMs(float diff_ms) override { |
| 100 | max_sample_diff_ms_ = diff_ms; |
| 101 | } |
sprang | fda496a | 2017-06-15 04:21:07 -0700 | [diff] [blame] | 102 | |
Niels Möller | e08cf3a | 2017-12-07 15:23:58 +0100 | [diff] [blame] | 103 | void FrameCaptured(const VideoFrame& frame, |
| 104 | int64_t time_when_first_seen_us, |
| 105 | int64_t last_capture_time_us) override { |
| 106 | if (last_capture_time_us != -1) |
| 107 | AddCaptureSample(1e-3 * (time_when_first_seen_us - last_capture_time_us)); |
| 108 | |
| 109 | frame_timing_.push_back(FrameTiming(frame.timestamp_us(), frame.timestamp(), |
| 110 | time_when_first_seen_us)); |
Niels Möller | 7dc26b7 | 2017-12-06 10:27:48 +0100 | [diff] [blame] | 111 | } |
| 112 | |
Danil Chapovalov | b9b146c | 2018-06-15 12:28:07 +0200 | [diff] [blame] | 113 | absl::optional<int> FrameSent( |
Niels Möller | 83dbeac | 2017-12-14 16:39:44 +0100 | [diff] [blame] | 114 | uint32_t timestamp, |
| 115 | int64_t time_sent_in_us, |
| 116 | int64_t /* capture_time_us */, |
Danil Chapovalov | b9b146c | 2018-06-15 12:28:07 +0200 | [diff] [blame] | 117 | absl::optional<int> /* encode_duration_us */) override { |
| 118 | absl::optional<int> encode_duration_us; |
Niels Möller | e08cf3a | 2017-12-07 15:23:58 +0100 | [diff] [blame] | 119 | // Delay before reporting actual encoding time, used to have the ability to |
| 120 | // detect total encoding time when encoding more than one layer. Encoding is |
| 121 | // here assumed to finish within a second (or that we get enough long-time |
| 122 | // samples before one second to trigger an overuse even when this is not the |
| 123 | // case). |
| 124 | static const int64_t kEncodingTimeMeasureWindowMs = 1000; |
| 125 | for (auto& it : frame_timing_) { |
| 126 | if (it.timestamp == timestamp) { |
| 127 | it.last_send_us = time_sent_in_us; |
| 128 | break; |
| 129 | } |
| 130 | } |
| 131 | // TODO(pbos): Handle the case/log errors when not finding the corresponding |
| 132 | // frame (either very slow encoding or incorrect wrong timestamps returned |
| 133 | // from the encoder). |
| 134 | // This is currently the case for all frames on ChromeOS, so logging them |
| 135 | // would be spammy, and triggering overuse would be wrong. |
| 136 | // https://crbug.com/350106 |
| 137 | while (!frame_timing_.empty()) { |
| 138 | FrameTiming timing = frame_timing_.front(); |
| 139 | if (time_sent_in_us - timing.capture_us < |
| 140 | kEncodingTimeMeasureWindowMs * rtc::kNumMicrosecsPerMillisec) { |
| 141 | break; |
| 142 | } |
| 143 | if (timing.last_send_us != -1) { |
| 144 | encode_duration_us.emplace( |
| 145 | static_cast<int>(timing.last_send_us - timing.capture_us)); |
Niels Möller | 6b642f7 | 2017-12-08 14:11:14 +0100 | [diff] [blame] | 146 | |
Niels Möller | e08cf3a | 2017-12-07 15:23:58 +0100 | [diff] [blame] | 147 | if (last_processed_capture_time_us_ != -1) { |
| 148 | int64_t diff_us = timing.capture_us - last_processed_capture_time_us_; |
| 149 | AddSample(1e-3 * (*encode_duration_us), 1e-3 * diff_us); |
| 150 | } |
| 151 | last_processed_capture_time_us_ = timing.capture_us; |
| 152 | } |
| 153 | frame_timing_.pop_front(); |
| 154 | } |
| 155 | return encode_duration_us; |
Niels Möller | 7dc26b7 | 2017-12-06 10:27:48 +0100 | [diff] [blame] | 156 | } |
| 157 | |
Niels Möller | 904f869 | 2017-12-07 11:22:39 +0100 | [diff] [blame] | 158 | int Value() override { |
Niels Möller | 7dc26b7 | 2017-12-06 10:27:48 +0100 | [diff] [blame] | 159 | if (count_ < static_cast<uint32_t>(options_.min_frame_samples)) { |
| 160 | return static_cast<int>(InitialUsageInPercent() + 0.5f); |
asapersson@webrtc.org | ce12f1f | 2014-03-24 21:59:16 +0000 | [diff] [blame] | 161 | } |
Niels Möller | 7dc26b7 | 2017-12-06 10:27:48 +0100 | [diff] [blame] | 162 | float frame_diff_ms = std::max(filtered_frame_diff_ms_->filtered(), 1.0f); |
| 163 | frame_diff_ms = std::min(frame_diff_ms, max_sample_diff_ms_); |
| 164 | float encode_usage_percent = |
| 165 | 100.0f * filtered_processing_ms_->filtered() / frame_diff_ms; |
| 166 | return static_cast<int>(encode_usage_percent + 0.5); |
asapersson@webrtc.org | 9e5b034 | 2013-12-04 13:47:44 +0000 | [diff] [blame] | 167 | } |
| 168 | |
asapersson@webrtc.org | 2881ab1 | 2014-06-12 08:46:46 +0000 | [diff] [blame] | 169 | private: |
Niels Möller | e08cf3a | 2017-12-07 15:23:58 +0100 | [diff] [blame] | 170 | struct FrameTiming { |
| 171 | FrameTiming(int64_t capture_time_us, uint32_t timestamp, int64_t now) |
| 172 | : capture_time_us(capture_time_us), |
| 173 | timestamp(timestamp), |
| 174 | capture_us(now), |
| 175 | last_send_us(-1) {} |
| 176 | int64_t capture_time_us; |
| 177 | uint32_t timestamp; |
| 178 | int64_t capture_us; |
| 179 | int64_t last_send_us; |
| 180 | }; |
| 181 | |
| 182 | void AddCaptureSample(float sample_ms) { |
| 183 | float exp = sample_ms / kDefaultSampleDiffMs; |
| 184 | exp = std::min(exp, kMaxExp); |
| 185 | filtered_frame_diff_ms_->Apply(exp, sample_ms); |
| 186 | } |
| 187 | |
| 188 | void AddSample(float processing_ms, int64_t diff_last_sample_ms) { |
| 189 | ++count_; |
| 190 | float exp = diff_last_sample_ms / kDefaultSampleDiffMs; |
| 191 | exp = std::min(exp, kMaxExp); |
| 192 | filtered_processing_ms_->Apply(exp, processing_ms); |
| 193 | } |
| 194 | |
Niels Möller | 7dc26b7 | 2017-12-06 10:27:48 +0100 | [diff] [blame] | 195 | float InitialUsageInPercent() const { |
| 196 | // Start in between the underuse and overuse threshold. |
| 197 | return (options_.low_encode_usage_threshold_percent + |
Yves Gerey | 665174f | 2018-06-19 15:03:05 +0200 | [diff] [blame] | 198 | options_.high_encode_usage_threshold_percent) / |
| 199 | 2.0f; |
Niels Möller | 7dc26b7 | 2017-12-06 10:27:48 +0100 | [diff] [blame] | 200 | } |
| 201 | |
| 202 | float InitialProcessingMs() const { |
| 203 | return InitialUsageInPercent() * kInitialSampleDiffMs / 100; |
| 204 | } |
| 205 | |
| 206 | const float kWeightFactorFrameDiff; |
| 207 | const float kWeightFactorProcessing; |
| 208 | const float kInitialSampleDiffMs; |
Niels Möller | e08cf3a | 2017-12-07 15:23:58 +0100 | [diff] [blame] | 209 | |
Peter Boström | 4b91bd0 | 2015-06-26 06:58:16 +0200 | [diff] [blame] | 210 | const CpuOveruseOptions options_; |
Niels Möller | e08cf3a | 2017-12-07 15:23:58 +0100 | [diff] [blame] | 211 | std::list<FrameTiming> frame_timing_; |
| 212 | uint64_t count_; |
| 213 | int64_t last_processed_capture_time_us_; |
Niels Möller | 7dc26b7 | 2017-12-06 10:27:48 +0100 | [diff] [blame] | 214 | float max_sample_diff_ms_; |
| 215 | std::unique_ptr<rtc::ExpFilter> filtered_processing_ms_; |
| 216 | std::unique_ptr<rtc::ExpFilter> filtered_frame_diff_ms_; |
asapersson@webrtc.org | 9e5b034 | 2013-12-04 13:47:44 +0000 | [diff] [blame] | 217 | }; |
| 218 | |
Niels Möller | 83dbeac | 2017-12-14 16:39:44 +0100 | [diff] [blame] | 219 | // New cpu load estimator. |
| 220 | // TODO(bugs.webrtc.org/8504): For some period of time, we need to |
| 221 | // switch between the two versions of the estimator for experiments. |
| 222 | // When problems are sorted out, the old estimator should be deleted. |
| 223 | class SendProcessingUsage2 : public OveruseFrameDetector::ProcessingUsage { |
sprang | c5d62e2 | 2017-04-02 23:53:04 -0700 | [diff] [blame] | 224 | public: |
Niels Möller | 83dbeac | 2017-12-14 16:39:44 +0100 | [diff] [blame] | 225 | explicit SendProcessingUsage2(const CpuOveruseOptions& options) |
| 226 | : options_(options) { |
| 227 | Reset(); |
| 228 | } |
Mirko Bonadei | fe055c1 | 2019-01-29 22:53:28 +0100 | [diff] [blame] | 229 | ~SendProcessingUsage2() override = default; |
Niels Möller | 83dbeac | 2017-12-14 16:39:44 +0100 | [diff] [blame] | 230 | |
| 231 | void Reset() override { |
| 232 | prev_time_us_ = -1; |
| 233 | // Start in between the underuse and overuse threshold. |
| 234 | load_estimate_ = (options_.low_encode_usage_threshold_percent + |
| 235 | options_.high_encode_usage_threshold_percent) / |
| 236 | 200.0; |
| 237 | } |
| 238 | |
| 239 | void SetMaxSampleDiffMs(float /* diff_ms */) override {} |
| 240 | |
| 241 | void FrameCaptured(const VideoFrame& frame, |
| 242 | int64_t time_when_first_seen_us, |
| 243 | int64_t last_capture_time_us) override {} |
| 244 | |
Danil Chapovalov | b9b146c | 2018-06-15 12:28:07 +0200 | [diff] [blame] | 245 | absl::optional<int> FrameSent( |
Niels Möller | f5033ad | 2018-08-14 17:00:46 +0200 | [diff] [blame] | 246 | uint32_t /* timestamp */, |
| 247 | int64_t /* time_sent_in_us */, |
Danil Chapovalov | b9b146c | 2018-06-15 12:28:07 +0200 | [diff] [blame] | 248 | int64_t capture_time_us, |
| 249 | absl::optional<int> encode_duration_us) override { |
Niels Möller | 83dbeac | 2017-12-14 16:39:44 +0100 | [diff] [blame] | 250 | if (encode_duration_us) { |
Niels Möller | f5033ad | 2018-08-14 17:00:46 +0200 | [diff] [blame] | 251 | int duration_per_frame_us = |
| 252 | DurationPerInputFrame(capture_time_us, *encode_duration_us); |
Niels Möller | 83dbeac | 2017-12-14 16:39:44 +0100 | [diff] [blame] | 253 | if (prev_time_us_ != -1) { |
Niels Möller | 58d2a5e | 2018-08-07 16:37:18 +0200 | [diff] [blame] | 254 | if (capture_time_us < prev_time_us_) { |
| 255 | // The weighting in AddSample assumes that samples are processed with |
| 256 | // non-decreasing measurement timestamps. We could implement |
| 257 | // appropriate weights for samples arriving late, but since it is a |
| 258 | // rare case, keep things simple, by just pushing those measurements a |
| 259 | // bit forward in time. |
| 260 | capture_time_us = prev_time_us_; |
| 261 | } |
Niels Möller | f5033ad | 2018-08-14 17:00:46 +0200 | [diff] [blame] | 262 | AddSample(1e-6 * duration_per_frame_us, |
Niels Möller | 83dbeac | 2017-12-14 16:39:44 +0100 | [diff] [blame] | 263 | 1e-6 * (capture_time_us - prev_time_us_)); |
| 264 | } |
| 265 | } |
| 266 | prev_time_us_ = capture_time_us; |
| 267 | |
| 268 | return encode_duration_us; |
| 269 | } |
| 270 | |
| 271 | private: |
| 272 | void AddSample(double encode_time, double diff_time) { |
| 273 | RTC_CHECK_GE(diff_time, 0.0); |
| 274 | |
| 275 | // Use the filter update |
| 276 | // |
| 277 | // load <-- x/d (1-exp (-d/T)) + exp (-d/T) load |
| 278 | // |
| 279 | // where we must take care for small d, using the proper limit |
| 280 | // (1 - exp(-d/tau)) / d = 1/tau - d/2tau^2 + O(d^2) |
| 281 | double tau = (1e-3 * options_.filter_time_ms); |
| 282 | double e = diff_time / tau; |
| 283 | double c; |
| 284 | if (e < 0.0001) { |
| 285 | c = (1 - e / 2) / tau; |
| 286 | } else { |
| 287 | c = -expm1(-e) / diff_time; |
| 288 | } |
| 289 | load_estimate_ = c * encode_time + exp(-e) * load_estimate_; |
| 290 | } |
| 291 | |
Niels Möller | f5033ad | 2018-08-14 17:00:46 +0200 | [diff] [blame] | 292 | int64_t DurationPerInputFrame(int64_t capture_time_us, |
| 293 | int64_t encode_time_us) { |
| 294 | // Discard data on old frames; limit 2 seconds. |
| 295 | static constexpr int64_t kMaxAge = 2 * rtc::kNumMicrosecsPerSec; |
| 296 | for (auto it = max_encode_time_per_input_frame_.begin(); |
| 297 | it != max_encode_time_per_input_frame_.end() && |
| 298 | it->first < capture_time_us - kMaxAge;) { |
| 299 | it = max_encode_time_per_input_frame_.erase(it); |
| 300 | } |
| 301 | |
| 302 | std::map<int64_t, int>::iterator it; |
| 303 | bool inserted; |
| 304 | std::tie(it, inserted) = max_encode_time_per_input_frame_.emplace( |
| 305 | capture_time_us, encode_time_us); |
| 306 | if (inserted) { |
| 307 | // First encoded frame for this input frame. |
| 308 | return encode_time_us; |
| 309 | } |
| 310 | if (encode_time_us <= it->second) { |
| 311 | // Shorter encode time than previous frame (unlikely). Count it as being |
| 312 | // done in parallel. |
| 313 | return 0; |
| 314 | } |
| 315 | // Record new maximum encode time, and return increase from previous max. |
| 316 | int increase = encode_time_us - it->second; |
| 317 | it->second = encode_time_us; |
| 318 | return increase; |
| 319 | } |
| 320 | |
Niels Möller | 83dbeac | 2017-12-14 16:39:44 +0100 | [diff] [blame] | 321 | int Value() override { |
| 322 | return static_cast<int>(100.0 * load_estimate_ + 0.5); |
| 323 | } |
| 324 | |
Niels Möller | 83dbeac | 2017-12-14 16:39:44 +0100 | [diff] [blame] | 325 | const CpuOveruseOptions options_; |
Niels Möller | f5033ad | 2018-08-14 17:00:46 +0200 | [diff] [blame] | 326 | // Indexed by the capture timestamp, used as frame id. |
| 327 | std::map<int64_t, int> max_encode_time_per_input_frame_; |
| 328 | |
Niels Möller | 83dbeac | 2017-12-14 16:39:44 +0100 | [diff] [blame] | 329 | int64_t prev_time_us_ = -1; |
| 330 | double load_estimate_; |
| 331 | }; |
| 332 | |
| 333 | // Class used for manual testing of overuse, enabled via field trial flag. |
| 334 | class OverdoseInjector : public OveruseFrameDetector::ProcessingUsage { |
| 335 | public: |
| 336 | OverdoseInjector(std::unique_ptr<OveruseFrameDetector::ProcessingUsage> usage, |
sprang | c5d62e2 | 2017-04-02 23:53:04 -0700 | [diff] [blame] | 337 | int64_t normal_period_ms, |
| 338 | int64_t overuse_period_ms, |
| 339 | int64_t underuse_period_ms) |
Niels Möller | 83dbeac | 2017-12-14 16:39:44 +0100 | [diff] [blame] | 340 | : usage_(std::move(usage)), |
sprang | c5d62e2 | 2017-04-02 23:53:04 -0700 | [diff] [blame] | 341 | normal_period_ms_(normal_period_ms), |
| 342 | overuse_period_ms_(overuse_period_ms), |
| 343 | underuse_period_ms_(underuse_period_ms), |
| 344 | state_(State::kNormal), |
| 345 | last_toggling_ms_(-1) { |
| 346 | RTC_DCHECK_GT(overuse_period_ms, 0); |
| 347 | RTC_DCHECK_GT(normal_period_ms, 0); |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 348 | RTC_LOG(LS_INFO) << "Simulating overuse with intervals " << normal_period_ms |
| 349 | << "ms normal mode, " << overuse_period_ms |
| 350 | << "ms overuse mode."; |
sprang | c5d62e2 | 2017-04-02 23:53:04 -0700 | [diff] [blame] | 351 | } |
| 352 | |
| 353 | ~OverdoseInjector() override {} |
| 354 | |
Niels Möller | 83dbeac | 2017-12-14 16:39:44 +0100 | [diff] [blame] | 355 | void Reset() override { usage_->Reset(); } |
| 356 | |
| 357 | void SetMaxSampleDiffMs(float diff_ms) override { |
| 358 | usage_->SetMaxSampleDiffMs(diff_ms); |
| 359 | } |
| 360 | |
| 361 | void FrameCaptured(const VideoFrame& frame, |
| 362 | int64_t time_when_first_seen_us, |
| 363 | int64_t last_capture_time_us) override { |
| 364 | usage_->FrameCaptured(frame, time_when_first_seen_us, last_capture_time_us); |
| 365 | } |
| 366 | |
Danil Chapovalov | b9b146c | 2018-06-15 12:28:07 +0200 | [diff] [blame] | 367 | absl::optional<int> FrameSent( |
Niels Möller | 83dbeac | 2017-12-14 16:39:44 +0100 | [diff] [blame] | 368 | // These two argument used by old estimator. |
| 369 | uint32_t timestamp, |
| 370 | int64_t time_sent_in_us, |
| 371 | // And these two by the new estimator. |
| 372 | int64_t capture_time_us, |
Danil Chapovalov | b9b146c | 2018-06-15 12:28:07 +0200 | [diff] [blame] | 373 | absl::optional<int> encode_duration_us) override { |
Niels Möller | 83dbeac | 2017-12-14 16:39:44 +0100 | [diff] [blame] | 374 | return usage_->FrameSent(timestamp, time_sent_in_us, capture_time_us, |
| 375 | encode_duration_us); |
| 376 | } |
| 377 | |
sprang | c5d62e2 | 2017-04-02 23:53:04 -0700 | [diff] [blame] | 378 | int Value() override { |
| 379 | int64_t now_ms = rtc::TimeMillis(); |
| 380 | if (last_toggling_ms_ == -1) { |
| 381 | last_toggling_ms_ = now_ms; |
| 382 | } else { |
| 383 | switch (state_) { |
| 384 | case State::kNormal: |
| 385 | if (now_ms > last_toggling_ms_ + normal_period_ms_) { |
| 386 | state_ = State::kOveruse; |
| 387 | last_toggling_ms_ = now_ms; |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 388 | RTC_LOG(LS_INFO) << "Simulating CPU overuse."; |
sprang | c5d62e2 | 2017-04-02 23:53:04 -0700 | [diff] [blame] | 389 | } |
| 390 | break; |
| 391 | case State::kOveruse: |
| 392 | if (now_ms > last_toggling_ms_ + overuse_period_ms_) { |
| 393 | state_ = State::kUnderuse; |
| 394 | last_toggling_ms_ = now_ms; |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 395 | RTC_LOG(LS_INFO) << "Simulating CPU underuse."; |
sprang | c5d62e2 | 2017-04-02 23:53:04 -0700 | [diff] [blame] | 396 | } |
| 397 | break; |
| 398 | case State::kUnderuse: |
| 399 | if (now_ms > last_toggling_ms_ + underuse_period_ms_) { |
| 400 | state_ = State::kNormal; |
| 401 | last_toggling_ms_ = now_ms; |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 402 | RTC_LOG(LS_INFO) << "Actual CPU overuse measurements in effect."; |
sprang | c5d62e2 | 2017-04-02 23:53:04 -0700 | [diff] [blame] | 403 | } |
| 404 | break; |
| 405 | } |
| 406 | } |
| 407 | |
Danil Chapovalov | b9b146c | 2018-06-15 12:28:07 +0200 | [diff] [blame] | 408 | absl::optional<int> overried_usage_value; |
sprang | c5d62e2 | 2017-04-02 23:53:04 -0700 | [diff] [blame] | 409 | switch (state_) { |
| 410 | case State::kNormal: |
| 411 | break; |
| 412 | case State::kOveruse: |
| 413 | overried_usage_value.emplace(250); |
| 414 | break; |
| 415 | case State::kUnderuse: |
| 416 | overried_usage_value.emplace(5); |
| 417 | break; |
| 418 | } |
Niels Möller | 7dc26b7 | 2017-12-06 10:27:48 +0100 | [diff] [blame] | 419 | |
Niels Möller | 83dbeac | 2017-12-14 16:39:44 +0100 | [diff] [blame] | 420 | return overried_usage_value.value_or(usage_->Value()); |
sprang | c5d62e2 | 2017-04-02 23:53:04 -0700 | [diff] [blame] | 421 | } |
| 422 | |
| 423 | private: |
Niels Möller | 83dbeac | 2017-12-14 16:39:44 +0100 | [diff] [blame] | 424 | const std::unique_ptr<OveruseFrameDetector::ProcessingUsage> usage_; |
sprang | c5d62e2 | 2017-04-02 23:53:04 -0700 | [diff] [blame] | 425 | const int64_t normal_period_ms_; |
| 426 | const int64_t overuse_period_ms_; |
| 427 | const int64_t underuse_period_ms_; |
| 428 | enum class State { kNormal, kOveruse, kUnderuse } state_; |
| 429 | int64_t last_toggling_ms_; |
| 430 | }; |
| 431 | |
Niels Möller | 904f869 | 2017-12-07 11:22:39 +0100 | [diff] [blame] | 432 | } // namespace |
| 433 | |
| 434 | CpuOveruseOptions::CpuOveruseOptions() |
| 435 | : high_encode_usage_threshold_percent(85), |
| 436 | frame_timeout_interval_ms(1500), |
| 437 | min_frame_samples(120), |
| 438 | min_process_count(3), |
Niels Möller | 83dbeac | 2017-12-14 16:39:44 +0100 | [diff] [blame] | 439 | high_threshold_consecutive_count(2), |
| 440 | // Disabled by default. |
| 441 | filter_time_ms(0) { |
Niels Möller | 904f869 | 2017-12-07 11:22:39 +0100 | [diff] [blame] | 442 | #if defined(WEBRTC_MAC) && !defined(WEBRTC_IOS) |
| 443 | // This is proof-of-concept code for letting the physical core count affect |
| 444 | // the interval into which we attempt to scale. For now, the code is Mac OS |
| 445 | // specific, since that's the platform were we saw most problems. |
| 446 | // TODO(torbjorng): Enhance SystemInfo to return this metric. |
| 447 | |
| 448 | mach_port_t mach_host = mach_host_self(); |
| 449 | host_basic_info hbi = {}; |
| 450 | mach_msg_type_number_t info_count = HOST_BASIC_INFO_COUNT; |
| 451 | kern_return_t kr = |
| 452 | host_info(mach_host, HOST_BASIC_INFO, reinterpret_cast<host_info_t>(&hbi), |
| 453 | &info_count); |
| 454 | mach_port_deallocate(mach_task_self(), mach_host); |
| 455 | |
| 456 | int n_physical_cores; |
| 457 | if (kr != KERN_SUCCESS) { |
| 458 | // If we couldn't get # of physical CPUs, don't panic. Assume we have 1. |
| 459 | n_physical_cores = 1; |
| 460 | RTC_LOG(LS_ERROR) |
| 461 | << "Failed to determine number of physical cores, assuming 1"; |
| 462 | } else { |
| 463 | n_physical_cores = hbi.physical_cpu; |
| 464 | RTC_LOG(LS_INFO) << "Number of physical cores:" << n_physical_cores; |
| 465 | } |
| 466 | |
| 467 | // Change init list default for few core systems. The assumption here is that |
| 468 | // encoding, which we measure here, takes about 1/4 of the processing of a |
| 469 | // two-way call. This is roughly true for x86 using both vp8 and vp9 without |
| 470 | // hardware encoding. Since we don't affect the incoming stream here, we only |
| 471 | // control about 1/2 of the total processing needs, but this is not taken into |
| 472 | // account. |
| 473 | if (n_physical_cores == 1) |
| 474 | high_encode_usage_threshold_percent = 20; // Roughly 1/4 of 100%. |
| 475 | else if (n_physical_cores == 2) |
| 476 | high_encode_usage_threshold_percent = 40; // Roughly 1/4 of 200%. |
| 477 | #endif // defined(WEBRTC_MAC) && !defined(WEBRTC_IOS) |
| 478 | |
| 479 | // Note that we make the interval 2x+epsilon wide, since libyuv scaling steps |
| 480 | // are close to that (when squared). This wide interval makes sure that |
| 481 | // scaling up or down does not jump all the way across the interval. |
| 482 | low_encode_usage_threshold_percent = |
| 483 | (high_encode_usage_threshold_percent - 1) / 2; |
| 484 | } |
| 485 | |
| 486 | std::unique_ptr<OveruseFrameDetector::ProcessingUsage> |
Yves Gerey | 665174f | 2018-06-19 15:03:05 +0200 | [diff] [blame] | 487 | OveruseFrameDetector::CreateProcessingUsage(const CpuOveruseOptions& options) { |
Niels Möller | 904f869 | 2017-12-07 11:22:39 +0100 | [diff] [blame] | 488 | std::unique_ptr<ProcessingUsage> instance; |
Niels Möller | 83dbeac | 2017-12-14 16:39:44 +0100 | [diff] [blame] | 489 | if (options.filter_time_ms > 0) { |
Mirko Bonadei | 317a1f0 | 2019-09-17 17:06:18 +0200 | [diff] [blame] | 490 | instance = std::make_unique<SendProcessingUsage2>(options); |
Niels Möller | 83dbeac | 2017-12-14 16:39:44 +0100 | [diff] [blame] | 491 | } else { |
Mirko Bonadei | 317a1f0 | 2019-09-17 17:06:18 +0200 | [diff] [blame] | 492 | instance = std::make_unique<SendProcessingUsage1>(options); |
Niels Möller | 83dbeac | 2017-12-14 16:39:44 +0100 | [diff] [blame] | 493 | } |
sprang | c5d62e2 | 2017-04-02 23:53:04 -0700 | [diff] [blame] | 494 | std::string toggling_interval = |
| 495 | field_trial::FindFullName("WebRTC-ForceSimulatedOveruseIntervalMs"); |
| 496 | if (!toggling_interval.empty()) { |
| 497 | int normal_period_ms = 0; |
| 498 | int overuse_period_ms = 0; |
| 499 | int underuse_period_ms = 0; |
| 500 | if (sscanf(toggling_interval.c_str(), "%d-%d-%d", &normal_period_ms, |
| 501 | &overuse_period_ms, &underuse_period_ms) == 3) { |
| 502 | if (normal_period_ms > 0 && overuse_period_ms > 0 && |
| 503 | underuse_period_ms > 0) { |
Mirko Bonadei | 317a1f0 | 2019-09-17 17:06:18 +0200 | [diff] [blame] | 504 | instance = std::make_unique<OverdoseInjector>( |
Yves Gerey | 665174f | 2018-06-19 15:03:05 +0200 | [diff] [blame] | 505 | std::move(instance), normal_period_ms, overuse_period_ms, |
| 506 | underuse_period_ms); |
sprang | c5d62e2 | 2017-04-02 23:53:04 -0700 | [diff] [blame] | 507 | } else { |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 508 | RTC_LOG(LS_WARNING) |
sprang | c5d62e2 | 2017-04-02 23:53:04 -0700 | [diff] [blame] | 509 | << "Invalid (non-positive) normal/overuse/underuse periods: " |
| 510 | << normal_period_ms << " / " << overuse_period_ms << " / " |
| 511 | << underuse_period_ms; |
| 512 | } |
| 513 | } else { |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 514 | RTC_LOG(LS_WARNING) << "Malformed toggling interval: " |
| 515 | << toggling_interval; |
sprang | c5d62e2 | 2017-04-02 23:53:04 -0700 | [diff] [blame] | 516 | } |
| 517 | } |
sprang | c5d62e2 | 2017-04-02 23:53:04 -0700 | [diff] [blame] | 518 | return instance; |
| 519 | } |
| 520 | |
pbos@webrtc.org | 3e6e271 | 2015-02-26 12:19:31 +0000 | [diff] [blame] | 521 | OveruseFrameDetector::OveruseFrameDetector( |
pbos@webrtc.org | 3e6e271 | 2015-02-26 12:19:31 +0000 | [diff] [blame] | 522 | CpuOveruseMetricsObserver* metrics_observer) |
Sebastian Jansson | ecb6897 | 2019-01-18 10:30:54 +0100 | [diff] [blame] | 523 | : metrics_observer_(metrics_observer), |
asapersson@webrtc.org | b60346e | 2014-02-17 19:02:15 +0000 | [diff] [blame] | 524 | num_process_times_(0), |
Danil Chapovalov | b9b146c | 2018-06-15 12:28:07 +0200 | [diff] [blame] | 525 | // TODO(nisse): Use absl::optional |
nisse | e0e3bdf | 2017-01-18 02:16:20 -0800 | [diff] [blame] | 526 | last_capture_time_us_(-1), |
asapersson | 74d85e1 | 2015-09-24 00:53:32 -0700 | [diff] [blame] | 527 | num_pixels_(0), |
Niels Möller | 7dc26b7 | 2017-12-06 10:27:48 +0100 | [diff] [blame] | 528 | max_framerate_(kDefaultFrameRate), |
Peter Boström | e449915 | 2016-02-05 11:13:28 +0100 | [diff] [blame] | 529 | last_overuse_time_ms_(-1), |
pbos@webrtc.org | a957570 | 2013-08-30 17:16:32 +0000 | [diff] [blame] | 530 | checks_above_threshold_(0), |
asapersson@webrtc.org | d980307 | 2014-06-16 14:27:19 +0000 | [diff] [blame] | 531 | num_overuse_detections_(0), |
Peter Boström | e449915 | 2016-02-05 11:13:28 +0100 | [diff] [blame] | 532 | last_rampup_time_ms_(-1), |
pbos@webrtc.org | a957570 | 2013-08-30 17:16:32 +0000 | [diff] [blame] | 533 | in_quick_rampup_(false), |
Niels Möller | d1f7eb6 | 2018-03-28 16:40:58 +0200 | [diff] [blame] | 534 | current_rampup_delay_ms_(kStandardRampUpDelayMs) { |
perkj | d52063f | 2016-09-07 06:32:18 -0700 | [diff] [blame] | 535 | task_checker_.Detach(); |
Niels Möller | eea9288 | 2019-04-25 08:44:04 +0200 | [diff] [blame] | 536 | ParseFieldTrial({&filter_time_constant_}, |
| 537 | field_trial::FindFullName("WebRTC-CpuLoadEstimator")); |
asapersson@webrtc.org | 9e5b034 | 2013-12-04 13:47:44 +0000 | [diff] [blame] | 538 | } |
mflodman@webrtc.org | e6168f5 | 2013-06-26 11:23:01 +0000 | [diff] [blame] | 539 | |
Sebastian Jansson | ecb6897 | 2019-01-18 10:30:54 +0100 | [diff] [blame] | 540 | OveruseFrameDetector::~OveruseFrameDetector() {} |
perkj | d52063f | 2016-09-07 06:32:18 -0700 | [diff] [blame] | 541 | |
Niels Möller | 73f29cb | 2018-01-31 16:09:31 +0100 | [diff] [blame] | 542 | void OveruseFrameDetector::StartCheckForOveruse( |
Sebastian Jansson | cda86dd | 2019-03-11 17:26:36 +0100 | [diff] [blame] | 543 | rtc::TaskQueue* task_queue, |
Niels Möller | d1f7eb6 | 2018-03-28 16:40:58 +0200 | [diff] [blame] | 544 | const CpuOveruseOptions& options, |
Niels Möller | 73f29cb | 2018-01-31 16:09:31 +0100 | [diff] [blame] | 545 | AdaptationObserverInterface* overuse_observer) { |
Sebastian Jansson | b55015e | 2019-04-09 13:44:04 +0200 | [diff] [blame] | 546 | RTC_DCHECK_RUN_ON(&task_checker_); |
Sebastian Jansson | ecb6897 | 2019-01-18 10:30:54 +0100 | [diff] [blame] | 547 | RTC_DCHECK(!check_overuse_task_.Running()); |
Niels Möller | 73f29cb | 2018-01-31 16:09:31 +0100 | [diff] [blame] | 548 | RTC_DCHECK(overuse_observer != nullptr); |
Niels Möller | d1f7eb6 | 2018-03-28 16:40:58 +0200 | [diff] [blame] | 549 | |
| 550 | SetOptions(options); |
Sebastian Jansson | ecb6897 | 2019-01-18 10:30:54 +0100 | [diff] [blame] | 551 | check_overuse_task_ = RepeatingTaskHandle::DelayedStart( |
Sebastian Jansson | cda86dd | 2019-03-11 17:26:36 +0100 | [diff] [blame] | 552 | task_queue->Get(), TimeDelta::ms(kTimeToFirstCheckForOveruseMs), |
| 553 | [this, overuse_observer] { |
Sebastian Jansson | ecb6897 | 2019-01-18 10:30:54 +0100 | [diff] [blame] | 554 | CheckForOveruse(overuse_observer); |
| 555 | return TimeDelta::ms(kCheckForOveruseIntervalMs); |
| 556 | }); |
perkj | d52063f | 2016-09-07 06:32:18 -0700 | [diff] [blame] | 557 | } |
| 558 | void OveruseFrameDetector::StopCheckForOveruse() { |
Sebastian Jansson | b55015e | 2019-04-09 13:44:04 +0200 | [diff] [blame] | 559 | RTC_DCHECK_RUN_ON(&task_checker_); |
Sebastian Jansson | ecb6897 | 2019-01-18 10:30:54 +0100 | [diff] [blame] | 560 | check_overuse_task_.Stop(); |
mflodman@webrtc.org | e6168f5 | 2013-06-26 11:23:01 +0000 | [diff] [blame] | 561 | } |
| 562 | |
Peter Boström | e449915 | 2016-02-05 11:13:28 +0100 | [diff] [blame] | 563 | void OveruseFrameDetector::EncodedFrameTimeMeasured(int encode_duration_ms) { |
Sebastian Jansson | b55015e | 2019-04-09 13:44:04 +0200 | [diff] [blame] | 564 | RTC_DCHECK_RUN_ON(&task_checker_); |
Niels Möller | 213618e | 2018-07-24 09:29:58 +0200 | [diff] [blame] | 565 | encode_usage_percent_ = usage_->Value(); |
asapersson@webrtc.org | 9aed002 | 2014-10-16 06:57:12 +0000 | [diff] [blame] | 566 | |
Niels Möller | 213618e | 2018-07-24 09:29:58 +0200 | [diff] [blame] | 567 | metrics_observer_->OnEncodedFrameTimeMeasured(encode_duration_ms, |
| 568 | *encode_usage_percent_); |
asapersson@webrtc.org | ab6bf4f | 2014-05-27 07:43:15 +0000 | [diff] [blame] | 569 | } |
| 570 | |
asapersson@webrtc.org | 8a8c3ef | 2014-03-20 13:15:01 +0000 | [diff] [blame] | 571 | bool OveruseFrameDetector::FrameSizeChanged(int num_pixels) const { |
Sebastian Jansson | b55015e | 2019-04-09 13:44:04 +0200 | [diff] [blame] | 572 | RTC_DCHECK_RUN_ON(&task_checker_); |
asapersson@webrtc.org | 8a8c3ef | 2014-03-20 13:15:01 +0000 | [diff] [blame] | 573 | if (num_pixels != num_pixels_) { |
| 574 | return true; |
| 575 | } |
| 576 | return false; |
| 577 | } |
| 578 | |
nisse | e0e3bdf | 2017-01-18 02:16:20 -0800 | [diff] [blame] | 579 | bool OveruseFrameDetector::FrameTimeoutDetected(int64_t now_us) const { |
Sebastian Jansson | b55015e | 2019-04-09 13:44:04 +0200 | [diff] [blame] | 580 | RTC_DCHECK_RUN_ON(&task_checker_); |
nisse | e0e3bdf | 2017-01-18 02:16:20 -0800 | [diff] [blame] | 581 | if (last_capture_time_us_ == -1) |
asapersson@webrtc.org | b60346e | 2014-02-17 19:02:15 +0000 | [diff] [blame] | 582 | return false; |
nisse | e0e3bdf | 2017-01-18 02:16:20 -0800 | [diff] [blame] | 583 | return (now_us - last_capture_time_us_) > |
Yves Gerey | 665174f | 2018-06-19 15:03:05 +0200 | [diff] [blame] | 584 | options_.frame_timeout_interval_ms * rtc::kNumMicrosecsPerMillisec; |
asapersson@webrtc.org | 8a8c3ef | 2014-03-20 13:15:01 +0000 | [diff] [blame] | 585 | } |
| 586 | |
Niels Möller | 7dc26b7 | 2017-12-06 10:27:48 +0100 | [diff] [blame] | 587 | void OveruseFrameDetector::ResetAll(int num_pixels) { |
| 588 | // Reset state, as a result resolution being changed. Do not however change |
| 589 | // the current frame rate back to the default. |
Sebastian Jansson | b55015e | 2019-04-09 13:44:04 +0200 | [diff] [blame] | 590 | RTC_DCHECK_RUN_ON(&task_checker_); |
Niels Möller | 7dc26b7 | 2017-12-06 10:27:48 +0100 | [diff] [blame] | 591 | num_pixels_ = num_pixels; |
asapersson@webrtc.org | 9aed002 | 2014-10-16 06:57:12 +0000 | [diff] [blame] | 592 | usage_->Reset(); |
nisse | e0e3bdf | 2017-01-18 02:16:20 -0800 | [diff] [blame] | 593 | last_capture_time_us_ = -1; |
asapersson@webrtc.org | 8a8c3ef | 2014-03-20 13:15:01 +0000 | [diff] [blame] | 594 | num_process_times_ = 0; |
Niels Möller | 213618e | 2018-07-24 09:29:58 +0200 | [diff] [blame] | 595 | encode_usage_percent_ = absl::nullopt; |
Niels Möller | 7dc26b7 | 2017-12-06 10:27:48 +0100 | [diff] [blame] | 596 | OnTargetFramerateUpdated(max_framerate_); |
sprang | fda496a | 2017-06-15 04:21:07 -0700 | [diff] [blame] | 597 | } |
| 598 | |
Niels Möller | 7dc26b7 | 2017-12-06 10:27:48 +0100 | [diff] [blame] | 599 | void OveruseFrameDetector::OnTargetFramerateUpdated(int framerate_fps) { |
Sebastian Jansson | b55015e | 2019-04-09 13:44:04 +0200 | [diff] [blame] | 600 | RTC_DCHECK_RUN_ON(&task_checker_); |
Niels Möller | 7dc26b7 | 2017-12-06 10:27:48 +0100 | [diff] [blame] | 601 | RTC_DCHECK_GE(framerate_fps, 0); |
| 602 | max_framerate_ = std::min(kMaxFramerate, framerate_fps); |
| 603 | usage_->SetMaxSampleDiffMs((1000 / std::max(kMinFramerate, max_framerate_)) * |
| 604 | kMaxSampleDiffMarginFactor); |
asapersson@webrtc.org | 9aed002 | 2014-10-16 06:57:12 +0000 | [diff] [blame] | 605 | } |
| 606 | |
Niels Möller | 7dc26b7 | 2017-12-06 10:27:48 +0100 | [diff] [blame] | 607 | void OveruseFrameDetector::FrameCaptured(const VideoFrame& frame, |
| 608 | int64_t time_when_first_seen_us) { |
Sebastian Jansson | b55015e | 2019-04-09 13:44:04 +0200 | [diff] [blame] | 609 | RTC_DCHECK_RUN_ON(&task_checker_); |
Niels Möller | eee7ced | 2017-12-01 11:25:01 +0100 | [diff] [blame] | 610 | |
Niels Möller | 7dc26b7 | 2017-12-06 10:27:48 +0100 | [diff] [blame] | 611 | if (FrameSizeChanged(frame.width() * frame.height()) || |
| 612 | FrameTimeoutDetected(time_when_first_seen_us)) { |
| 613 | ResetAll(frame.width() * frame.height()); |
| 614 | } |
| 615 | |
Niels Möller | e08cf3a | 2017-12-07 15:23:58 +0100 | [diff] [blame] | 616 | usage_->FrameCaptured(frame, time_when_first_seen_us, last_capture_time_us_); |
Niels Möller | 7dc26b7 | 2017-12-06 10:27:48 +0100 | [diff] [blame] | 617 | last_capture_time_us_ = time_when_first_seen_us; |
Niels Möller | 7dc26b7 | 2017-12-06 10:27:48 +0100 | [diff] [blame] | 618 | } |
| 619 | |
| 620 | void OveruseFrameDetector::FrameSent(uint32_t timestamp, |
Niels Möller | 83dbeac | 2017-12-14 16:39:44 +0100 | [diff] [blame] | 621 | int64_t time_sent_in_us, |
| 622 | int64_t capture_time_us, |
Danil Chapovalov | b9b146c | 2018-06-15 12:28:07 +0200 | [diff] [blame] | 623 | absl::optional<int> encode_duration_us) { |
Sebastian Jansson | b55015e | 2019-04-09 13:44:04 +0200 | [diff] [blame] | 624 | RTC_DCHECK_RUN_ON(&task_checker_); |
Niels Möller | 83dbeac | 2017-12-14 16:39:44 +0100 | [diff] [blame] | 625 | encode_duration_us = usage_->FrameSent(timestamp, time_sent_in_us, |
| 626 | capture_time_us, encode_duration_us); |
Niels Möller | e08cf3a | 2017-12-07 15:23:58 +0100 | [diff] [blame] | 627 | |
| 628 | if (encode_duration_us) { |
| 629 | EncodedFrameTimeMeasured(*encode_duration_us / |
| 630 | rtc::kNumMicrosecsPerMillisec); |
Peter Boström | e449915 | 2016-02-05 11:13:28 +0100 | [diff] [blame] | 631 | } |
asapersson@webrtc.org | c7ff8f9 | 2013-11-26 11:12:33 +0000 | [diff] [blame] | 632 | } |
| 633 | |
Niels Möller | 73f29cb | 2018-01-31 16:09:31 +0100 | [diff] [blame] | 634 | void OveruseFrameDetector::CheckForOveruse( |
| 635 | AdaptationObserverInterface* observer) { |
Sebastian Jansson | b55015e | 2019-04-09 13:44:04 +0200 | [diff] [blame] | 636 | RTC_DCHECK_RUN_ON(&task_checker_); |
Niels Möller | 73f29cb | 2018-01-31 16:09:31 +0100 | [diff] [blame] | 637 | RTC_DCHECK(observer); |
perkj | d52063f | 2016-09-07 06:32:18 -0700 | [diff] [blame] | 638 | ++num_process_times_; |
Niels Möller | 213618e | 2018-07-24 09:29:58 +0200 | [diff] [blame] | 639 | if (num_process_times_ <= options_.min_process_count || |
| 640 | !encode_usage_percent_) |
perkj | d52063f | 2016-09-07 06:32:18 -0700 | [diff] [blame] | 641 | return; |
pbos@webrtc.org | a957570 | 2013-08-30 17:16:32 +0000 | [diff] [blame] | 642 | |
nisse | e0e3bdf | 2017-01-18 02:16:20 -0800 | [diff] [blame] | 643 | int64_t now_ms = rtc::TimeMillis(); |
pbos@webrtc.org | a957570 | 2013-08-30 17:16:32 +0000 | [diff] [blame] | 644 | |
Niels Möller | 213618e | 2018-07-24 09:29:58 +0200 | [diff] [blame] | 645 | if (IsOverusing(*encode_usage_percent_)) { |
pbos@webrtc.org | a957570 | 2013-08-30 17:16:32 +0000 | [diff] [blame] | 646 | // If the last thing we did was going up, and now have to back down, we need |
| 647 | // to check if this peak was short. If so we should back off to avoid going |
| 648 | // back and forth between this load, the system doesn't seem to handle it. |
Peter Boström | e449915 | 2016-02-05 11:13:28 +0100 | [diff] [blame] | 649 | bool check_for_backoff = last_rampup_time_ms_ > last_overuse_time_ms_; |
pbos@webrtc.org | a957570 | 2013-08-30 17:16:32 +0000 | [diff] [blame] | 650 | if (check_for_backoff) { |
nisse | e0e3bdf | 2017-01-18 02:16:20 -0800 | [diff] [blame] | 651 | if (now_ms - last_rampup_time_ms_ < kStandardRampUpDelayMs || |
asapersson@webrtc.org | d980307 | 2014-06-16 14:27:19 +0000 | [diff] [blame] | 652 | num_overuse_detections_ > kMaxOverusesBeforeApplyRampupDelay) { |
pbos@webrtc.org | a957570 | 2013-08-30 17:16:32 +0000 | [diff] [blame] | 653 | // Going up was not ok for very long, back off. |
| 654 | current_rampup_delay_ms_ *= kRampUpBackoffFactor; |
| 655 | if (current_rampup_delay_ms_ > kMaxRampUpDelayMs) |
| 656 | current_rampup_delay_ms_ = kMaxRampUpDelayMs; |
| 657 | } else { |
| 658 | // Not currently backing off, reset rampup delay. |
| 659 | current_rampup_delay_ms_ = kStandardRampUpDelayMs; |
| 660 | } |
| 661 | } |
| 662 | |
nisse | e0e3bdf | 2017-01-18 02:16:20 -0800 | [diff] [blame] | 663 | last_overuse_time_ms_ = now_ms; |
pbos@webrtc.org | a957570 | 2013-08-30 17:16:32 +0000 | [diff] [blame] | 664 | in_quick_rampup_ = false; |
| 665 | checks_above_threshold_ = 0; |
asapersson@webrtc.org | d980307 | 2014-06-16 14:27:19 +0000 | [diff] [blame] | 666 | ++num_overuse_detections_; |
pbos@webrtc.org | a957570 | 2013-08-30 17:16:32 +0000 | [diff] [blame] | 667 | |
Niels Möller | 73f29cb | 2018-01-31 16:09:31 +0100 | [diff] [blame] | 668 | observer->AdaptDown(kScaleReasonCpu); |
Niels Möller | 213618e | 2018-07-24 09:29:58 +0200 | [diff] [blame] | 669 | } else if (IsUnderusing(*encode_usage_percent_, now_ms)) { |
nisse | e0e3bdf | 2017-01-18 02:16:20 -0800 | [diff] [blame] | 670 | last_rampup_time_ms_ = now_ms; |
pbos@webrtc.org | a957570 | 2013-08-30 17:16:32 +0000 | [diff] [blame] | 671 | in_quick_rampup_ = true; |
| 672 | |
Niels Möller | 73f29cb | 2018-01-31 16:09:31 +0100 | [diff] [blame] | 673 | observer->AdaptUp(kScaleReasonCpu); |
mflodman@webrtc.org | e6168f5 | 2013-06-26 11:23:01 +0000 | [diff] [blame] | 674 | } |
pbos@webrtc.org | a957570 | 2013-08-30 17:16:32 +0000 | [diff] [blame] | 675 | |
mflodman@webrtc.org | 5574dac | 2014-04-07 10:56:31 +0000 | [diff] [blame] | 676 | int rampup_delay = |
| 677 | in_quick_rampup_ ? kQuickRampUpDelayMs : current_rampup_delay_ms_; |
asapersson | 74d85e1 | 2015-09-24 00:53:32 -0700 | [diff] [blame] | 678 | |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 679 | RTC_LOG(LS_VERBOSE) << " Frame stats: " |
Niels Möller | 213618e | 2018-07-24 09:29:58 +0200 | [diff] [blame] | 680 | << " encode usage " << *encode_usage_percent_ |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 681 | << " overuse detections " << num_overuse_detections_ |
| 682 | << " rampup delay " << rampup_delay; |
asapersson@webrtc.org | e2af622 | 2013-09-23 20:05:39 +0000 | [diff] [blame] | 683 | } |
| 684 | |
Niels Möller | d1f7eb6 | 2018-03-28 16:40:58 +0200 | [diff] [blame] | 685 | void OveruseFrameDetector::SetOptions(const CpuOveruseOptions& options) { |
Sebastian Jansson | b55015e | 2019-04-09 13:44:04 +0200 | [diff] [blame] | 686 | RTC_DCHECK_RUN_ON(&task_checker_); |
Niels Möller | d1f7eb6 | 2018-03-28 16:40:58 +0200 | [diff] [blame] | 687 | options_ = options; |
Niels Möller | eea9288 | 2019-04-25 08:44:04 +0200 | [diff] [blame] | 688 | |
| 689 | // Time constant config overridable by field trial. |
| 690 | if (filter_time_constant_) { |
| 691 | options_.filter_time_ms = filter_time_constant_->ms(); |
| 692 | } |
Niels Möller | d1f7eb6 | 2018-03-28 16:40:58 +0200 | [diff] [blame] | 693 | // Force reset with next frame. |
| 694 | num_pixels_ = 0; |
| 695 | usage_ = CreateProcessingUsage(options); |
| 696 | } |
| 697 | |
Niels Möller | 213618e | 2018-07-24 09:29:58 +0200 | [diff] [blame] | 698 | bool OveruseFrameDetector::IsOverusing(int usage_percent) { |
Sebastian Jansson | b55015e | 2019-04-09 13:44:04 +0200 | [diff] [blame] | 699 | RTC_DCHECK_RUN_ON(&task_checker_); |
sprang | c5d62e2 | 2017-04-02 23:53:04 -0700 | [diff] [blame] | 700 | |
Niels Möller | 213618e | 2018-07-24 09:29:58 +0200 | [diff] [blame] | 701 | if (usage_percent >= options_.high_encode_usage_threshold_percent) { |
pbos@webrtc.org | a957570 | 2013-08-30 17:16:32 +0000 | [diff] [blame] | 702 | ++checks_above_threshold_; |
| 703 | } else { |
| 704 | checks_above_threshold_ = 0; |
| 705 | } |
asapersson@webrtc.org | 8a8c3ef | 2014-03-20 13:15:01 +0000 | [diff] [blame] | 706 | return checks_above_threshold_ >= options_.high_threshold_consecutive_count; |
mflodman@webrtc.org | d4412fe | 2013-07-31 16:42:21 +0000 | [diff] [blame] | 707 | } |
| 708 | |
Niels Möller | 213618e | 2018-07-24 09:29:58 +0200 | [diff] [blame] | 709 | bool OveruseFrameDetector::IsUnderusing(int usage_percent, int64_t time_now) { |
Sebastian Jansson | b55015e | 2019-04-09 13:44:04 +0200 | [diff] [blame] | 710 | RTC_DCHECK_RUN_ON(&task_checker_); |
pbos@webrtc.org | a957570 | 2013-08-30 17:16:32 +0000 | [diff] [blame] | 711 | int delay = in_quick_rampup_ ? kQuickRampUpDelayMs : current_rampup_delay_ms_; |
Peter Boström | e449915 | 2016-02-05 11:13:28 +0100 | [diff] [blame] | 712 | if (time_now < last_rampup_time_ms_ + delay) |
mflodman@webrtc.org | d4412fe | 2013-07-31 16:42:21 +0000 | [diff] [blame] | 713 | return false; |
mflodman@webrtc.org | d4412fe | 2013-07-31 16:42:21 +0000 | [diff] [blame] | 714 | |
Niels Möller | 213618e | 2018-07-24 09:29:58 +0200 | [diff] [blame] | 715 | return usage_percent < options_.low_encode_usage_threshold_percent; |
mflodman@webrtc.org | d4412fe | 2013-07-31 16:42:21 +0000 | [diff] [blame] | 716 | } |
mflodman@webrtc.org | e6168f5 | 2013-06-26 11:23:01 +0000 | [diff] [blame] | 717 | } // namespace webrtc |