Evaluation tests

webrtc/modules/remote_bitrate_estimator/test/metric_recorder.cc

 /*
  *  Copyright (c) 2015 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 284 matching lines @@
   const double kBeta = 1.0;
 
   double throughput_metric = U(Sum(throughput_bytes_), kAlpha);
   double delay_penalty = kDelta * U(Sum(delays_ms_), kBeta);
 
   return throughput_metric - delay_penalty;
 }
 
 void MetricRecorder::PlotThroughputHistogram(const std::string& title,
                                              const std::string& bwe_name,
-                                             int num_flows,
+                                             size_t num_flows,
                                              int64_t extra_offset_ms,
                                              const std::string optimum_id) {
   size_t num_packets_received = delays_ms_.size();
 
   int64_t duration_ms = now_ms_ - start_computing_metrics_ms_ - extra_offset_ms;
 
   double average_bitrate_kbps =
       static_cast<double>(8 * Sum(throughput_bytes_) / duration_ms);
 
   double optimal_bitrate_per_flow_kbps =
@@ skipping 24 matching lines @@
                             optimal_bitrate_per_flow_kbps);
 
   RTC_UNUSED(p_error);
   RTC_UNUSED(n_error);
   RTC_UNUSED(extra_error);
   RTC_UNUSED(optimal_bitrate_per_flow_kbps);
 }
 
 void MetricRecorder::PlotThroughputHistogram(const std::string& title,
                                              const std::string& bwe_name,
-                                             int num_flows,
+                                             size_t num_flows,
                                              int64_t extra_offset_ms) {
   PlotThroughputHistogram(title, bwe_name, num_flows, extra_offset_ms, "");
 }
 
 void MetricRecorder::PlotDelayHistogram(const std::string& title,
                                         const std::string& bwe_name,
-                                        int num_flows,
+                                        size_t num_flows,
                                         int64_t one_way_path_delay_ms) {
   size_t num_packets_received = delays_ms_.size();
   double average_delay_ms = Average(delays_ms_, num_packets_received);
 
   // Prevent the error to be too close to zero (plotting issue).
   double extra_error = average_delay_ms / 500;
 
   double tenth_sigma_ms =
       StandardDeviation(delays_ms_, num_packets_received) / 10.0 + extra_error;
 
@@ skipping 20 matching lines @@
   BWE_TEST_LOGGING_LOG1("RESULTS >>> " + bwe_name + " Delay 95th percentile : ",
                         "%ld ms", percentile_95_ms - one_way_path_delay_ms);
 
   RTC_UNUSED(tenth_sigma_ms);
   RTC_UNUSED(percentile_5_ms);
   RTC_UNUSED(percentile_95_ms);
 }
 
 void MetricRecorder::PlotLossHistogram(const std::string& title,
                                        const std::string& bwe_name,
-                                       int num_flows,
+                                       size_t num_flows,
                                        float global_loss_ratio) {
   BWE_TEST_LOGGING_LABEL(6, title, "packet_loss_ratio_(%)", num_flows)
   BWE_TEST_LOGGING_BAR(6, bwe_name, 100.0f * global_loss_ratio, flow_id_);
 
   BWE_TEST_LOGGING_LOG1("RESULTS >>> " + bwe_name + " Loss Ratio : ", "%f %%",
                         100.0f * global_loss_ratio);
 }
 
 void MetricRecorder::PlotObjectiveHistogram(const std::string& title,
                                             const std::string& bwe_name,
-                                            int num_flows) {
+                                            size_t num_flows) {
   BWE_TEST_LOGGING_LABEL(7, title, "objective_function", num_flows)
   BWE_TEST_LOGGING_BAR(7, bwe_name, ObjectiveFunction(), flow_id_);
 }
 
 void MetricRecorder::PlotZero() {
   for (int i = kThroughput; i <= kLoss; ++i) {
     if (plot_information_[i].plot) {
       std::stringstream prefix;
       prefix << "Receiver_" << flow_id_ << "_" + plot_information_[i].prefix;
       PlotLine(i, prefix.str(), now_ms_, 0);
       plot_information_[i].last_plot_ms = now_ms_;
     }
   }
 }
 
 void MetricRecorder::PauseFlow() {
   PlotZero();
   link_share_->PauseFlow(flow_id_);
 }
 
 void MetricRecorder::ResumeFlow(int64_t paused_time_ms) {
   UpdateTime(now_ms_ + paused_time_ms);
   PlotZero();
   link_share_->ResumeFlow(flow_id_);
 }
 
 }  // namespace bwe
 }  // namespace testing
 }  // namespace webrtc