BWE Simulation Framework: Standard plot logging

webrtc/modules/remote_bitrate_estimator/test/bwe_test.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 294 matching lines @@
 
   int64_t one_way_delay_ms = rtt_ms / 2;
   DelayFilter delay_uplink(&uplink_, all_flow_ids);
   delay_uplink.SetOneWayDelayMs(one_way_delay_ms);
 
   JitterFilter jitter(&uplink_, all_flow_ids);
   jitter.SetMaxJitter(max_jitter_ms);
 
   std::vector<RateCounterFilter*> rate_counters;
   for (int flow : all_flow_ids) {
-    rate_counters.push_back(
-        new RateCounterFilter(&uplink_, flow, "receiver_input"));
+    rate_counters.push_back(new RateCounterFilter(&uplink_, flow, "Receiver"));
   }
 
   RateCounterFilter total_utilization(&uplink_, all_flow_ids,
                                       "total_utilization");
 
   std::vector<PacketReceiver*> receivers;
   // Delays is being plotted only for the first flow.
   // To plot all of them, replace "i == 0" with "true" on new PacketReceiver().
   for (int media_flow : media_flow_ids) {
     metric_recorders.push_back(
@@ skipping 159 matching lines @@
     senders.push_back(new VideoSender(&uplink_, sources[i], bwe_type));
   }
 
   FlowIds flow_ids = CreateFlowIdRange(0, static_cast<int>(num_flows - 1));
 
   DefaultEvaluationFilter up_filter(&uplink_, flow_ids);
   LinkShare link_share(&(up_filter.choke));
 
   RateCounterFilter total_utilization(&uplink_, flow_ids, "Total_utilization");
 
-  // Delays is being plotted only for the first flow.
-  // To plot all of them, replace "i == 0" with "true" on new PacketReceiver().
   for (size_t i = 0; i < num_flows; ++i) {
     metric_recorders.push_back(new MetricRecorder(
         bwe_names[bwe_type], static_cast<int>(i), senders[i], &link_share));
 
     receivers.push_back(new PacketReceiver(&uplink_, static_cast<int>(i),
-                                           bwe_type, i == 0, false,
+                                           bwe_type, false, false,

[stefan-webrtc, 2015/07/24 09:30:42]

Who is responsible for plotting delays in this test now?

[magalhaesc, 2015/07/24 11:46:40]

The delay is being plotted by the metric_recorder.
I will fix this since the metric_recorder is actually called by the
packet_receiver

                                            metric_recorders[i]));
     metric_recorders[i]->set_plot_available_capacity(
         i == 0 && plot_total_available_capacity_);
   }
 
   DelayFilter down_filter(&downlink_, flow_ids);
   down_filter.SetOneWayDelayMs(kOneWayDelayMs);
   // Test also with one way propagation delay = 100ms.
   // up_filter.delay.SetOneWayDelayMs(100);
   // down_filter.SetOneWayDelayMs(100);
@@ skipping 47 matching lines @@
   sources[kBackward].reset(new AdaptiveVideoSource(kBackward, 30, 300, 0, 0));
   senders[kBackward].reset(
       new VideoSender(&downlink_, sources[kBackward].get(), bwe_type));
 
   DefaultEvaluationFilter up_filter(&uplink_, kForward);
   LinkShare up_link_share(&(up_filter.choke));
 
   metric_recorders[kForward].reset(new MetricRecorder(
       bwe_names[bwe_type], kForward, senders[kForward].get(), &up_link_share));
   receivers[kForward].reset(
-      new PacketReceiver(&uplink_, kForward, bwe_type, true, false,
+      new PacketReceiver(&uplink_, kForward, bwe_type, false, false,
                          metric_recorders[kForward].get()));
 
   metric_recorders[kForward].get()->set_plot_available_capacity(
       plot_total_available_capacity_);
 
   DefaultEvaluationFilter down_filter(&downlink_, kBackward);
   LinkShare down_link_share(&(down_filter.choke));
 
   metric_recorders[kBackward].reset(
       new MetricRecorder(bwe_names[bwe_type], kBackward,
                          senders[kBackward].get(), &down_link_share));
   receivers[kBackward].reset(
-      new PacketReceiver(&downlink_, kBackward, bwe_type, true, false,
+      new PacketReceiver(&downlink_, kBackward, bwe_type, false, false,
                          metric_recorders[kBackward].get()));
 
   metric_recorders[kBackward].get()->set_plot_available_capacity(
       plot_total_available_capacity_);
 
   // Test also with one way propagation delay = 100ms.
   // up_filter.delay.SetOneWayDelayMs(100);
   // down_filter.delay.SetOneWayDelayMs(100);
 
   up_filter.choke.set_capacity_kbps(2000);
@@ skipping 82 matching lines @@
   JitterFilter jitter_filter(&uplink_, CreateFlowIds(kAllFlowIds, kNumFlows));
 
   rtc::scoped_ptr<DelayFilter> up_delay_filters[kNumFlows];
   for (size_t i = 0; i < kNumFlows; ++i) {
     up_delay_filters[i].reset(new DelayFilter(&uplink_, kAllFlowIds[i]));
   }
 
   RateCounterFilter total_utilization(
       &uplink_, CreateFlowIds(kAllFlowIds, kNumFlows), "Total_utilization");
 
-  // Delays is being plotted only for the first flow.
-  // To plot all of them, replace "i == 0" with "true" on new PacketReceiver().
   rtc::scoped_ptr<PacketReceiver> receivers[kNumFlows];
   for (size_t i = 0; i < kNumFlows; ++i) {
     metric_recorders[i].reset(
         new MetricRecorder(bwe_names[bwe_type], static_cast<int>(i),
                            senders[i].get(), &link_share));
 
     receivers[i].reset(new PacketReceiver(&uplink_, kAllFlowIds[i], bwe_type,
-                                          i == 0, false,
+                                          false, false,
                                           metric_recorders[i].get()));
     metric_recorders[i].get()->set_start_computing_metrics_ms(kStartingApartMs *
                                                               (kNumFlows - 1));
     metric_recorders[i].get()->set_plot_available_capacity(
         i == 0 && plot_total_available_capacity_);
   }
 
   rtc::scoped_ptr<DelayFilter> down_delay_filters[kNumFlows];
   for (size_t i = 0; i < kNumFlows; ++i) {
     down_delay_filters[i].reset(new DelayFilter(&downlink_, kAllFlowIds[i]));
@@ skipping 85 matching lines @@
                                     tcp_file_sizes_bytes[id - kNumRmcatFlows]));
   }
 
   FlowIds flow_ids = CreateFlowIdRange(0, static_cast<int>(kNumTotalFlows - 1));
   DefaultEvaluationFilter up_filter(&uplink_, flow_ids);
 
   LinkShare link_share(&(up_filter.choke));
 
   RateCounterFilter total_utilization(&uplink_, flow_ids, "Total_utilization");
 
-  // Delays is being plotted only for the first flow.
-  // To plot all of them, replace "i == 0" with "true" on new PacketReceiver().
   for (size_t id : kAllRmcatFlowIds) {
     metric_recorders[id].reset(
         new MetricRecorder(bwe_names[bwe_type], static_cast<int>(id),
                            senders[id].get(), &link_share));
     receivers[id].reset(new PacketReceiver(&uplink_, static_cast<int>(id),
-                                           bwe_type, id == 0, false,
+                                           bwe_type, false, false,
                                            metric_recorders[id].get()));
     metric_recorders[id].get()->set_start_computing_metrics_ms(
         kRmcatStartingTimeMs);
     metric_recorders[id].get()->set_plot_available_capacity(
         id == 0 && plot_total_available_capacity_);
   }
 
-  // Delays is not being plotted only for TCP flows. To plot all of them,
-  // replace first "false" occurence with "true" on new PacketReceiver().
   for (size_t id : kAllTcpFlowIds) {
     metric_recorders[id].reset(
         new MetricRecorder(bwe_names[kTcpEstimator], static_cast<int>(id),
                            senders[id].get(), &link_share));
     receivers[id].reset(new PacketReceiver(&uplink_, static_cast<int>(id),
                                            kTcpEstimator, false, false,
                                            metric_recorders[id].get()));
     metric_recorders[id].get()->set_plot_available_capacity(
         id == 0 && plot_total_available_capacity_);
   }
@@ skipping 50 matching lines @@
   }
 
   DefaultEvaluationFilter filter(&uplink_,
                                  CreateFlowIds(kAllFlowIds, kNumFlows));
 
   LinkShare link_share(&(filter.choke));
 
   RateCounterFilter total_utilization(
       &uplink_, CreateFlowIds(kAllFlowIds, kNumFlows), "Total_utilization");
 
-  // Delays is being plotted only for the first flow.
-  // To plot all of them, replace "i == 0" with "true" on new PacketReceiver().
   for (size_t i = 0; i < kNumFlows; ++i) {
     metric_recorders[i].reset(
         new MetricRecorder(bwe_names[bwe_type], static_cast<int>(i),
                            senders[i].get(), &link_share));
     receivers[i].reset(new PacketReceiver(&uplink_, kAllFlowIds[i], bwe_type,
-                                          i == 0, false,
+                                          false, false,
                                           metric_recorders[i].get()));
     metric_recorders[i].get()->set_start_computing_metrics_ms(kStartingApartMs *
                                                               (kNumFlows - 1));
     metric_recorders[i].get()->set_plot_available_capacity(
         i == 0 && plot_total_available_capacity_);
   }
 
   // Test also with one way propagation delay = 100ms.
   // filter.delay.SetOneWayDelayMs(100);
   filter.choke.set_capacity_kbps(3500);
@@ skipping 63 matching lines @@
     tcp_starting_times_ms.push_back(
         static_cast<int64_t>(random.Exponential(1.0f / kMeanMs)));
   }
 
   return tcp_starting_times_ms;
 }
 
 }  // namespace bwe
 }  // namespace testing
 }  // namespace webrtc