Add UMA for send bwe and pacer bitrate.

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 96 matching lines @@
 
   VoiceEngine* voice_engine() {
     internal::AudioState* audio_state =
         static_cast<internal::AudioState*>(config_.audio_state.get());
     if (audio_state)
       return audio_state->voice_engine();
     else
       return nullptr;
   }
 
-  void UpdateHistograms();
+  void UpdateSendHistograms();
+  void UpdateReceiveHistograms();
 
   const Clock* const clock_;
 
   const int num_cpu_cores_;
   const rtc::scoped_ptr<ProcessThread> module_process_thread_;
   const rtc::scoped_ptr<CallStats> call_stats_;
   const rtc::scoped_ptr<BitrateAllocator> bitrate_allocator_;
   Call::Config config_;
   rtc::ThreadChecker configuration_thread_checker_;
 
@@ skipping 13 matching lines @@
   rtc::scoped_ptr<RWLockWrapper> send_crit_;
   // Audio and Video send streams are owned by the client that creates them.
   std::map<uint32_t, AudioSendStream*> audio_send_ssrcs_ GUARDED_BY(send_crit_);
   std::map<uint32_t, VideoSendStream*> video_send_ssrcs_ GUARDED_BY(send_crit_);
   std::set<VideoSendStream*> video_send_streams_ GUARDED_BY(send_crit_);
 
   VideoSendStream::RtpStateMap suspended_video_send_ssrcs_;
 
   RtcEventLog* event_log_ = nullptr;
 
-  // The RateTrackers are only accessed (exclusively) from DeliverRtp or
-  // DeliverRtcp, and from the destructor, and therefore doesn't need any
-  // explicit synchronization.
+  // The following members are only accessed (exclusively) from one thread and
+  // from the destructor, and therefore doesn't need any explicit
+  // synchronization.
   rtc::RateTracker received_video_bytes_per_sec_;
   rtc::RateTracker received_audio_bytes_per_sec_;
   rtc::RateTracker received_rtcp_bytes_per_sec_;
+  int64_t first_packet_sent_ms_;
   int64_t first_rtp_packet_received_ms_;
 
+  // TODO(holmer): Remove this lock once BitrateController no longer calls
+  // OnNetworkChanged from multiple threads.
+  rtc::CriticalSection bitrate_crit_;
+  rtc::RateTracker estimated_send_bitrate_kbps_ GUARDED_BY(&bitrate_crit_);
+  rtc::RateTracker pacer_bitrate_kbps_ GUARDED_BY(&bitrate_crit_);
+  uint32_t target_bitrate_bps_ GUARDED_BY(&bitrate_crit_);
+  uint32_t pacer_bitrate_bps_ GUARDED_BY(&bitrate_crit_);
+  int64_t last_bitrate_update_ms_ GUARDED_BY(&bitrate_crit_);
+
   const rtc::scoped_ptr<CongestionController> congestion_controller_;
 
   RTC_DISALLOW_COPY_AND_ASSIGN(Call);
 };
 }  // namespace internal
 
 Call* Call::Create(const Call::Config& config) {
   return new internal::Call(config);
 }
 
 namespace internal {
 
 Call::Call(const Call::Config& config)
     : clock_(Clock::GetRealTimeClock()),
       num_cpu_cores_(CpuInfo::DetectNumberOfCores()),
       module_process_thread_(ProcessThread::Create("ModuleProcessThread")),
       call_stats_(new CallStats()),
       bitrate_allocator_(new BitrateAllocator()),
       config_(config),
       network_enabled_(true),
       receive_crit_(RWLockWrapper::CreateRWLock()),
       send_crit_(RWLockWrapper::CreateRWLock()),
       received_video_bytes_per_sec_(1000, 1),
       received_audio_bytes_per_sec_(1000, 1),
       received_rtcp_bytes_per_sec_(1000, 1),
+      first_packet_sent_ms_(-1),
       first_rtp_packet_received_ms_(-1),
-      congestion_controller_(new CongestionController(
-          module_process_thread_.get(), call_stats_.get(), this)) {
+      estimated_send_bitrate_kbps_(1000, 1),
+      pacer_bitrate_kbps_(1000, 1),
+      target_bitrate_bps_(0),
+      pacer_bitrate_bps_(0),
+      last_bitrate_update_ms_(-1),
+      congestion_controller_(
+          new CongestionController(module_process_thread_.get(),
+                                   call_stats_.get(),
+                                   this)) {
   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) {
     RTC_DCHECK_GE(config.bitrate_config.max_bitrate_bps,
                   config.bitrate_config.start_bitrate_bps);
   }
   if (config.audio_state.get()) {
     ScopedVoEInterface<VoECodec> voe_codec(voice_engine());
     event_log_ = voe_codec->GetEventLog();
   }
 
   Trace::CreateTrace();
   module_process_thread_->Start();
   module_process_thread_->RegisterModule(call_stats_.get());
 
   congestion_controller_->SetBweBitrates(
       config_.bitrate_config.min_bitrate_bps,
       config_.bitrate_config.start_bitrate_bps,
       config_.bitrate_config.max_bitrate_bps);
 
   congestion_controller_->GetBitrateController()->SetEventLog(event_log_);
 }
 
 Call::~Call() {
   RTC_DCHECK(configuration_thread_checker_.CalledOnValidThread());
-  UpdateHistograms();
+  UpdateSendHistograms();
+  UpdateReceiveHistograms();
   RTC_CHECK(audio_send_ssrcs_.empty());
   RTC_CHECK(video_send_ssrcs_.empty());
   RTC_CHECK(video_send_streams_.empty());
   RTC_CHECK(audio_receive_ssrcs_.empty());
   RTC_CHECK(video_receive_ssrcs_.empty());
   RTC_CHECK(video_receive_streams_.empty());
 
   module_process_thread_->DeRegisterModule(call_stats_.get());
   module_process_thread_->Stop();
   Trace::ReturnTrace();
 }
 
-void Call::UpdateHistograms() {
+void Call::UpdateSendHistograms() {
+  if (first_packet_sent_ms_ == -1)
+    return;
+  int64_t elapsed_sec =
+      (clock_->TimeInMilliseconds() - first_packet_sent_ms_) / 1000;
+  if (elapsed_sec < metrics::kMinRunTimeInSeconds)
+    return;
+  rtc::CritScope lock(&bitrate_crit_);
+  int send_bitrate_kbps = estimated_send_bitrate_kbps_.ComputeTotalRate();
+  int pacer_bitrate_kbps = pacer_bitrate_kbps_.ComputeTotalRate();
+  if (send_bitrate_kbps > 0) {
+    RTC_HISTOGRAM_COUNTS_100000("WebRTC.Call.EstimatedSendBitrateInKbps",
+                                send_bitrate_kbps);
+  }
+  if (pacer_bitrate_kbps > 0) {
+    RTC_HISTOGRAM_COUNTS_100000("WebRTC.Call.PacerBitrateInKbps",
+                                pacer_bitrate_kbps);
+  }
+}
+
+void Call::UpdateReceiveHistograms() {
   if (first_rtp_packet_received_ms_ == -1)
     return;
   int64_t elapsed_sec =
       (clock_->TimeInMilliseconds() - first_rtp_packet_received_ms_) / 1000;
   if (elapsed_sec < metrics::kMinRunTimeInSeconds)
     return;
   int audio_bitrate_kbps =
       received_audio_bytes_per_sec_.ComputeTotalRate() * 8 / 1000;
   int video_bitrate_kbps =
       received_video_bytes_per_sec_.ComputeTotalRate() * 8 / 1000;
@@ skipping 284 matching lines @@
   }
   {
     ReadLockScoped write_lock(*receive_crit_);
     for (auto& kv : video_receive_ssrcs_) {
       kv.second->SignalNetworkState(state);
     }
   }
 }
 
 void Call::OnSentPacket(const rtc::SentPacket& sent_packet) {
+  if (first_packet_sent_ms_ == -1)
+    first_packet_sent_ms_ = clock_->TimeInMilliseconds();
   congestion_controller_->OnSentPacket(sent_packet);
 }
 
 void Call::OnNetworkChanged(uint32_t target_bitrate_bps, uint8_t fraction_loss,
                             int64_t rtt_ms) {
+  int64_t now_ms = clock_->TimeInMilliseconds();
+  int64_t time_since_last_update_ms = 0;
+  {
+    rtc::CritScope lock(&bitrate_crit_);
+    if (last_bitrate_update_ms_ >= 0)
+      time_since_last_update_ms = now_ms - last_bitrate_update_ms_;
+    estimated_send_bitrate_kbps_.AddSamples(
+        time_since_last_update_ms * (target_bitrate_bps_ / 1000) / 1000);
+    pacer_bitrate_kbps_.AddSamples(time_since_last_update_ms *
+                                   (pacer_bitrate_bps_ / 1000) / 1000);
+    target_bitrate_bps_ = target_bitrate_bps;
+    last_bitrate_update_ms_ = now_ms;
+  }
   uint32_t allocated_bitrate_bps = bitrate_allocator_->OnNetworkChanged(
       target_bitrate_bps, fraction_loss, rtt_ms);
 
   int pad_up_to_bitrate_bps = 0;
   {
     ReadLockScoped read_lock(*send_crit_);
     // No need to update as long as we're not sending.
     if (video_send_streams_.empty())
       return;
 
     for (VideoSendStream* stream : video_send_streams_)
       pad_up_to_bitrate_bps += stream->GetPaddingNeededBps();
   }
   // Allocated bitrate might be higher than bitrate estimate if enforcing min
   // bitrate, or lower if estimate is higher than the sum of max bitrates, so
   // set the pacer bitrate to the maximum of the two.
   uint32_t pacer_bitrate_bps =
       std::max(target_bitrate_bps, allocated_bitrate_bps);
+  {
+    rtc::CritScope lock(&bitrate_crit_);
+    pacer_bitrate_bps_ = pacer_bitrate_bps;
+  }
   congestion_controller_->UpdatePacerBitrate(
       target_bitrate_bps / 1000,
       PacedSender::kDefaultPaceMultiplier * pacer_bitrate_bps / 1000,
       pad_up_to_bitrate_bps / 1000);
 }
 
 void Call::ConfigureSync(const std::string& sync_group) {
   // Set sync only if there was no previous one.
   if (voice_engine() == nullptr || sync_group.empty())
     return;
@@ skipping 123 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