Update AvgCounter to have the ability to include last period metric for subsequent intervals withou…

webrtc/call/call.cc

 /*
  *  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.
  */
 
@@ skipping 25 matching lines @@
 #include "webrtc/modules/rtp_rtcp/source/byte_io.h"
 #include "webrtc/modules/utility/include/process_thread.h"
 #include "webrtc/system_wrappers/include/clock.h"
 #include "webrtc/system_wrappers/include/cpu_info.h"
 #include "webrtc/system_wrappers/include/critical_section_wrapper.h"
 #include "webrtc/system_wrappers/include/metrics.h"
 #include "webrtc/system_wrappers/include/rw_lock_wrapper.h"
 #include "webrtc/system_wrappers/include/trace.h"
 #include "webrtc/video/call_stats.h"
 #include "webrtc/video/send_delay_stats.h"
+#include "webrtc/video/stats_counter.h"
 #include "webrtc/video/video_receive_stream.h"
 #include "webrtc/video/video_send_stream.h"
 #include "webrtc/video/vie_remb.h"
 #include "webrtc/voice_engine/include/voe_codec.h"
 
 namespace webrtc {
 
 const int Call::Config::kDefaultStartBitrateBps = 300000;
 
 namespace internal {
@@ skipping 123 matching lines @@
   int64_t received_video_bytes_;
   int64_t received_audio_bytes_;
   int64_t received_rtcp_bytes_;
   int64_t first_rtp_packet_received_ms_;
   int64_t last_rtp_packet_received_ms_;
   int64_t first_packet_sent_ms_;
 
   // TODO(holmer): Remove this lock once BitrateController no longer calls
   // OnNetworkChanged from multiple threads.
   rtc::CriticalSection bitrate_crit_;
-  int64_t estimated_send_bitrate_sum_kbits_ GUARDED_BY(&bitrate_crit_);
-  int64_t pacer_bitrate_sum_kbits_ GUARDED_BY(&bitrate_crit_);
   uint32_t min_allocated_send_bitrate_bps_ GUARDED_BY(&bitrate_crit_);
-  int64_t num_bitrate_updates_ GUARDED_BY(&bitrate_crit_);
   uint32_t configured_max_padding_bitrate_bps_ GUARDED_BY(&bitrate_crit_);
+  AvgCounter estimated_send_bitrate_kbps_counter_ GUARDED_BY(&bitrate_crit_);
+  AvgCounter pacer_bitrate_kbps_counter_ GUARDED_BY(&bitrate_crit_);
 
   std::map<std::string, rtc::NetworkRoute> network_routes_;
 
   VieRemb remb_;
   const std::unique_ptr<CongestionController> congestion_controller_;
   const std::unique_ptr<SendDelayStats> video_send_delay_stats_;
   const int64_t start_ms_;
 
   RTC_DISALLOW_COPY_AND_ASSIGN(Call);
 };
@@ skipping 29 matching lines @@
       video_network_state_(kNetworkUp),
       receive_crit_(RWLockWrapper::CreateRWLock()),
       send_crit_(RWLockWrapper::CreateRWLock()),
       event_log_(RtcEventLog::Create(webrtc::Clock::GetRealTimeClock())),
       received_video_bytes_(0),
       received_audio_bytes_(0),
       received_rtcp_bytes_(0),
       first_rtp_packet_received_ms_(-1),
       last_rtp_packet_received_ms_(-1),
       first_packet_sent_ms_(-1),
-      estimated_send_bitrate_sum_kbits_(0),
-      pacer_bitrate_sum_kbits_(0),
       min_allocated_send_bitrate_bps_(0),
-      num_bitrate_updates_(0),
       configured_max_padding_bitrate_bps_(0),
+      estimated_send_bitrate_kbps_counter_(clock_, nullptr, true),
+      pacer_bitrate_kbps_counter_(clock_, nullptr, true),
       remb_(clock_),
       congestion_controller_(
           new CongestionController(clock_, this, &remb_, event_log_.get())),
       video_send_delay_stats_(new SendDelayStats(clock_)),
       start_ms_(clock_->TimeInMilliseconds()) {
   RTC_DCHECK(configuration_thread_checker_.CalledOnValidThread());
   RTC_DCHECK_GE(config.bitrate_config.min_bitrate_bps, 0);
   RTC_DCHECK_GE(config.bitrate_config.start_bitrate_bps,
                 config.bitrate_config.min_bitrate_bps);
   if (config.bitrate_config.max_bitrate_bps != -1) {
@@ skipping 46 matching lines @@
   Trace::ReturnTrace();
 }
 
 void Call::UpdateHistograms() {
   RTC_LOGGED_HISTOGRAM_COUNTS_100000(
       "WebRTC.Call.LifetimeInSeconds",
       (clock_->TimeInMilliseconds() - start_ms_) / 1000);
 }
 
 void Call::UpdateSendHistograms() {
-  if (num_bitrate_updates_ == 0 || first_packet_sent_ms_ == -1)
+  if (first_packet_sent_ms_ == -1)
     return;
   int64_t elapsed_sec =
       (clock_->TimeInMilliseconds() - first_packet_sent_ms_) / 1000;
   if (elapsed_sec < metrics::kMinRunTimeInSeconds)
     return;
-  int send_bitrate_kbps =
-      estimated_send_bitrate_sum_kbits_ / num_bitrate_updates_;
-  int pacer_bitrate_kbps = pacer_bitrate_sum_kbits_ / num_bitrate_updates_;
-  if (send_bitrate_kbps > 0) {
+  const int kMinRequiredPeriodicSamples = 5;
+  AggregatedStats send_bitrate_stats =
+      estimated_send_bitrate_kbps_counter_.ProcessAndGetStats();
+  if (send_bitrate_stats.num_samples >= kMinRequiredPeriodicSamples) {
     RTC_LOGGED_HISTOGRAM_COUNTS_100000("WebRTC.Call.EstimatedSendBitrateInKbps",
-                                       send_bitrate_kbps);
+                                       send_bitrate_stats.average);
   }
-  if (pacer_bitrate_kbps > 0) {
+  AggregatedStats pacer_bitrate_stats =
+      pacer_bitrate_kbps_counter_.ProcessAndGetStats();
+  if (pacer_bitrate_stats.num_samples >= kMinRequiredPeriodicSamples) {
     RTC_LOGGED_HISTOGRAM_COUNTS_100000("WebRTC.Call.PacerBitrateInKbps",
-                                       pacer_bitrate_kbps);
+                                       pacer_bitrate_stats.average);
   }
 }
 
 void Call::UpdateReceiveHistograms() {
   if (first_rtp_packet_received_ms_ == -1)
     return;
   int64_t elapsed_sec =
       (last_rtp_packet_received_ms_ - first_rtp_packet_received_ms_) / 1000;
   if (elapsed_sec < metrics::kMinRunTimeInSeconds)
     return;
@@ skipping 385 matching lines @@
   video_send_delay_stats_->OnSentPacket(sent_packet.packet_id,
                                         clock_->TimeInMilliseconds());
   congestion_controller_->OnSentPacket(sent_packet);
 }
 
 void Call::OnNetworkChanged(uint32_t target_bitrate_bps, uint8_t fraction_loss,
                             int64_t rtt_ms) {
   bitrate_allocator_->OnNetworkChanged(target_bitrate_bps, fraction_loss,
                                        rtt_ms);
 
-  // Ignore updates where the bitrate is zero because the aggregate network
-  // state is down.
-  if (target_bitrate_bps > 0) {
-    {
-      ReadLockScoped read_lock(*send_crit_);
-      // Do not update the stats if we are not sending video.
-      if (video_send_streams_.empty())
-        return;
-    }
+  // Ignore updates if bitrate is zero (the aggregate network state is down).
+  if (target_bitrate_bps == 0) {
     rtc::CritScope lock(&bitrate_crit_);
-    // We only update these stats if we have send streams, and assume that
-    // OnNetworkChanged is called roughly with a fixed frequency.
-    estimated_send_bitrate_sum_kbits_ += target_bitrate_bps / 1000;
-    // Pacer bitrate might be higher than bitrate estimate if enforcing min
-    // bitrate.
-    uint32_t pacer_bitrate_bps =
-        std::max(target_bitrate_bps, min_allocated_send_bitrate_bps_);
-    pacer_bitrate_sum_kbits_ += pacer_bitrate_bps / 1000;
-    ++num_bitrate_updates_;
+    estimated_send_bitrate_kbps_counter_.ProcessAndPause();
+    pacer_bitrate_kbps_counter_.ProcessAndPause();
+    return;
   }
+
+  bool sending_video;
+  {
+    ReadLockScoped read_lock(*send_crit_);
+    sending_video = !video_send_streams_.empty();
+  }
+
+  rtc::CritScope lock(&bitrate_crit_);
+  if (!sending_video) {
+    // Do not update the stats if we are not sending video.
+    estimated_send_bitrate_kbps_counter_.ProcessAndPause();
+    pacer_bitrate_kbps_counter_.ProcessAndPause();
+    return;
+  }
+  estimated_send_bitrate_kbps_counter_.Add(target_bitrate_bps / 1000);
+  // Pacer bitrate may be higher than bitrate estimate if enforcing min bitrate.
+  uint32_t pacer_bitrate_bps =
+      std::max(target_bitrate_bps, min_allocated_send_bitrate_bps_);
+  pacer_bitrate_kbps_counter_.Add(pacer_bitrate_bps / 1000);
 }
 
 void Call::OnAllocationLimitsChanged(uint32_t min_send_bitrate_bps,
                                      uint32_t max_padding_bitrate_bps) {
   congestion_controller_->SetAllocatedSendBitrateLimits(
       min_send_bitrate_bps, max_padding_bitrate_bps);
   rtc::CritScope lock(&bitrate_crit_);
   min_allocated_send_bitrate_bps_ = min_send_bitrate_bps;
   configured_max_padding_bitrate_bps_ = max_padding_bitrate_bps;
 }
@@ skipping 142 matching lines @@
   // thread. Then this check can be enabled.
   // RTC_DCHECK(!configuration_thread_checker_.CalledOnValidThread());
   if (RtpHeaderParser::IsRtcp(packet, length))
     return DeliverRtcp(media_type, packet, length);
 
   return DeliverRtp(media_type, packet, length, packet_time);
 }
 
 }  // namespace internal
 }  // namespace webrtc