1 /*
2 * Copyright (c) 2012 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
11 #include "video/call_stats.h"
12
13 #include <algorithm>
14 #include <memory>
15
16 #include "absl/algorithm/container.h"
17 #include "modules/utility/include/process_thread.h"
18 #include "rtc_base/checks.h"
19 #include "rtc_base/location.h"
20 #include "rtc_base/task_utils/to_queued_task.h"
21 #include "system_wrappers/include/metrics.h"
22
23 namespace webrtc {
24 namespace {
25
RemoveOldReports(int64_t now,std::list<CallStats::RttTime> * reports)26 void RemoveOldReports(int64_t now, std::list<CallStats::RttTime>* reports) {
27 static constexpr const int64_t kRttTimeoutMs = 1500;
28 reports->remove_if(
29 [&now](CallStats::RttTime& r) { return now - r.time > kRttTimeoutMs; });
30 }
31
GetMaxRttMs(const std::list<CallStats::RttTime> & reports)32 int64_t GetMaxRttMs(const std::list<CallStats::RttTime>& reports) {
33 int64_t max_rtt_ms = -1;
34 for (const CallStats::RttTime& rtt_time : reports)
35 max_rtt_ms = std::max(rtt_time.rtt, max_rtt_ms);
36 return max_rtt_ms;
37 }
38
GetAvgRttMs(const std::list<CallStats::RttTime> & reports)39 int64_t GetAvgRttMs(const std::list<CallStats::RttTime>& reports) {
40 RTC_DCHECK(!reports.empty());
41 int64_t sum = 0;
42 for (std::list<CallStats::RttTime>::const_iterator it = reports.begin();
43 it != reports.end(); ++it) {
44 sum += it->rtt;
45 }
46 return sum / reports.size();
47 }
48
GetNewAvgRttMs(const std::list<CallStats::RttTime> & reports,int64_t prev_avg_rtt)49 int64_t GetNewAvgRttMs(const std::list<CallStats::RttTime>& reports,
50 int64_t prev_avg_rtt) {
51 if (reports.empty())
52 return -1; // Reset (invalid average).
53
54 int64_t cur_rtt_ms = GetAvgRttMs(reports);
55 if (prev_avg_rtt == -1)
56 return cur_rtt_ms; // New initial average value.
57
58 // Weight factor to apply to the average rtt.
59 // We weigh the old average at 70% against the new average (30%).
60 constexpr const float kWeightFactor = 0.3f;
61 return prev_avg_rtt * (1.0f - kWeightFactor) + cur_rtt_ms * kWeightFactor;
62 }
63
64 // This class is used to de-register a Module from a ProcessThread to satisfy
65 // threading requirements of the Module (CallStats).
66 // The guarantee offered by TemporaryDeregistration is that while its in scope,
67 // no calls to |TimeUntilNextProcess| or |Process()| will occur and therefore
68 // synchronization with those methods, is not necessary.
69 class TemporaryDeregistration {
70 public:
TemporaryDeregistration(Module * module,ProcessThread * process_thread,bool thread_running)71 TemporaryDeregistration(Module* module,
72 ProcessThread* process_thread,
73 bool thread_running)
74 : module_(module),
75 process_thread_(process_thread),
76 deregistered_(thread_running) {
77 if (thread_running)
78 process_thread_->DeRegisterModule(module_);
79 }
~TemporaryDeregistration()80 ~TemporaryDeregistration() {
81 if (deregistered_)
82 process_thread_->RegisterModule(module_, RTC_FROM_HERE);
83 }
84
85 private:
86 Module* const module_;
87 ProcessThread* const process_thread_;
88 const bool deregistered_;
89 };
90
91 } // namespace
92
CallStats(Clock * clock,ProcessThread * process_thread)93 CallStats::CallStats(Clock* clock, ProcessThread* process_thread)
94 : clock_(clock),
95 last_process_time_(clock_->TimeInMilliseconds()),
96 max_rtt_ms_(-1),
97 avg_rtt_ms_(-1),
98 sum_avg_rtt_ms_(0),
99 num_avg_rtt_(0),
100 time_of_first_rtt_ms_(-1),
101 process_thread_(process_thread),
102 process_thread_running_(false) {
103 RTC_DCHECK(process_thread_);
104 process_thread_checker_.Detach();
105 }
106
~CallStats()107 CallStats::~CallStats() {
108 RTC_DCHECK_RUN_ON(&construction_thread_checker_);
109 RTC_DCHECK(!process_thread_running_);
110 RTC_DCHECK(observers_.empty());
111
112 UpdateHistograms();
113 }
114
TimeUntilNextProcess()115 int64_t CallStats::TimeUntilNextProcess() {
116 RTC_DCHECK_RUN_ON(&process_thread_checker_);
117 return last_process_time_ + kUpdateIntervalMs - clock_->TimeInMilliseconds();
118 }
119
Process()120 void CallStats::Process() {
121 RTC_DCHECK_RUN_ON(&process_thread_checker_);
122 int64_t now = clock_->TimeInMilliseconds();
123 last_process_time_ = now;
124
125 // |avg_rtt_ms_| is allowed to be read on the process thread since that's the
126 // only thread that modifies the value.
127 int64_t avg_rtt_ms = avg_rtt_ms_;
128 RemoveOldReports(now, &reports_);
129 max_rtt_ms_ = GetMaxRttMs(reports_);
130 avg_rtt_ms = GetNewAvgRttMs(reports_, avg_rtt_ms);
131 {
132 MutexLock lock(&avg_rtt_ms_lock_);
133 avg_rtt_ms_ = avg_rtt_ms;
134 }
135
136 // If there is a valid rtt, update all observers with the max rtt.
137 if (max_rtt_ms_ >= 0) {
138 RTC_DCHECK_GE(avg_rtt_ms, 0);
139 for (CallStatsObserver* observer : observers_)
140 observer->OnRttUpdate(avg_rtt_ms, max_rtt_ms_);
141 // Sum for Histogram of average RTT reported over the entire call.
142 sum_avg_rtt_ms_ += avg_rtt_ms;
143 ++num_avg_rtt_;
144 }
145 }
146
ProcessThreadAttached(ProcessThread * process_thread)147 void CallStats::ProcessThreadAttached(ProcessThread* process_thread) {
148 RTC_DCHECK_RUN_ON(&construction_thread_checker_);
149 RTC_DCHECK(!process_thread || process_thread_ == process_thread);
150 process_thread_running_ = process_thread != nullptr;
151
152 // Whether we just got attached or detached, we clear the
153 // |process_thread_checker_| so that it can be used to protect variables
154 // in either the process thread when it starts again, or UpdateHistograms()
155 // (mutually exclusive).
156 process_thread_checker_.Detach();
157 }
158
RegisterStatsObserver(CallStatsObserver * observer)159 void CallStats::RegisterStatsObserver(CallStatsObserver* observer) {
160 RTC_DCHECK_RUN_ON(&construction_thread_checker_);
161 TemporaryDeregistration deregister(this, process_thread_,
162 process_thread_running_);
163
164 if (!absl::c_linear_search(observers_, observer))
165 observers_.push_back(observer);
166 }
167
DeregisterStatsObserver(CallStatsObserver * observer)168 void CallStats::DeregisterStatsObserver(CallStatsObserver* observer) {
169 RTC_DCHECK_RUN_ON(&construction_thread_checker_);
170 TemporaryDeregistration deregister(this, process_thread_,
171 process_thread_running_);
172 observers_.remove(observer);
173 }
174
LastProcessedRtt() const175 int64_t CallStats::LastProcessedRtt() const {
176 // TODO(tommi): This currently gets called from the construction thread of
177 // Call as well as from the process thread. Look into restricting this to
178 // allow only reading this from the process thread (or TQ once we get there)
179 // so that the lock isn't necessary.
180
181 MutexLock lock(&avg_rtt_ms_lock_);
182 return avg_rtt_ms_;
183 }
184
OnRttUpdate(int64_t rtt)185 void CallStats::OnRttUpdate(int64_t rtt) {
186 RTC_DCHECK_RUN_ON(&process_thread_checker_);
187
188 int64_t now_ms = clock_->TimeInMilliseconds();
189 reports_.push_back(RttTime(rtt, now_ms));
190 if (time_of_first_rtt_ms_ == -1)
191 time_of_first_rtt_ms_ = now_ms;
192
193 // Make sure Process() will be called and deliver the updates asynchronously.
194 last_process_time_ -= kUpdateIntervalMs;
195 process_thread_->WakeUp(this);
196 }
197
UpdateHistograms()198 void CallStats::UpdateHistograms() {
199 RTC_DCHECK_RUN_ON(&construction_thread_checker_);
200 RTC_DCHECK(!process_thread_running_);
201
202 // The extra scope is because we have two 'dcheck run on' thread checkers.
203 // This is a special case since it's safe to access variables on the current
204 // thread that normally are only touched on the process thread.
205 // Since we're not attached to the process thread and/or the process thread
206 // isn't running, it's OK to touch these variables here.
207 {
208 // This method is called on the ctor thread (usually from the dtor, unless
209 // a test calls it). It's a requirement that the function be called when
210 // the process thread is not running (a condition that's met at destruction
211 // time), and thanks to that, we don't need a lock to synchronize against
212 // it.
213 RTC_DCHECK_RUN_ON(&process_thread_checker_);
214
215 if (time_of_first_rtt_ms_ == -1 || num_avg_rtt_ < 1)
216 return;
217
218 int64_t elapsed_sec =
219 (clock_->TimeInMilliseconds() - time_of_first_rtt_ms_) / 1000;
220 if (elapsed_sec >= metrics::kMinRunTimeInSeconds) {
221 int64_t avg_rtt_ms = (sum_avg_rtt_ms_ + num_avg_rtt_ / 2) / num_avg_rtt_;
222 RTC_HISTOGRAM_COUNTS_10000(
223 "WebRTC.Video.AverageRoundTripTimeInMilliseconds", avg_rtt_ms);
224 }
225 }
226 }
227
228 } // namespace webrtc
229