1 /*
2  *  Copyright (c) 2013 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 #ifndef WEBRTC_MODULES_REMOTE_BITRATE_ESTIMATOR_TEST_BWE_TEST_H_
12 #define WEBRTC_MODULES_REMOTE_BITRATE_ESTIMATOR_TEST_BWE_TEST_H_
13 
14 #include <map>
15 #include <string>
16 #include <vector>
17 #include "testing/gtest/include/gtest/gtest.h"
18 #include "webrtc/base/constructormagic.h"
19 #include "webrtc/modules/remote_bitrate_estimator/include/remote_bitrate_estimator.h"
20 #include "webrtc/modules/remote_bitrate_estimator/test/bwe.h"
21 #include "webrtc/modules/remote_bitrate_estimator/test/bwe_test_framework.h"
22 
23 namespace webrtc {
24 
25 namespace testing {
26 namespace bwe {
27 
28 class BweReceiver;
29 class PacketReceiver;
30 class PacketSender;
31 
32 class PacketProcessorRunner {
33  public:
34   explicit PacketProcessorRunner(PacketProcessor* processor);
35   ~PacketProcessorRunner();
36 
37   bool RunsProcessor(const PacketProcessor* processor) const;
38   void RunFor(int64_t time_ms, int64_t time_now_ms, Packets* in_out);
39 
40  private:
41   void FindPacketsToProcess(const FlowIds& flow_ids, Packets* in, Packets* out);
42   void QueuePackets(Packets* batch, int64_t end_of_batch_time_us);
43 
44   PacketProcessor* processor_;
45   Packets queue_;
46 };
47 
48 class Link : public PacketProcessorListener {
49  public:
~Link()50   virtual ~Link() {}
51 
52   virtual void AddPacketProcessor(PacketProcessor* processor,
53                                   ProcessorType type);
54   virtual void RemovePacketProcessor(PacketProcessor* processor);
55 
56   void Run(int64_t run_for_ms, int64_t now_ms, Packets* packets);
57 
senders()58   const std::vector<PacketSender*>& senders() { return senders_; }
processors()59   const std::vector<PacketProcessorRunner>& processors() { return processors_; }
60 
61  private:
62   std::vector<PacketSender*> senders_;
63   std::vector<PacketReceiver*> receivers_;
64   std::vector<PacketProcessorRunner> processors_;
65 };
66 
67 class BweTest {
68  public:
69   BweTest();
70   explicit BweTest(bool plot_capacity);
71   ~BweTest();
72 
73   void RunChoke(BandwidthEstimatorType bwe_type,
74                 std::vector<int> capacities_kbps);
75 
76   void RunVariableCapacity1SingleFlow(BandwidthEstimatorType bwe_type);
77   void RunVariableCapacity2MultipleFlows(BandwidthEstimatorType bwe_type,
78                                          size_t num_flows);
79   void RunBidirectionalFlow(BandwidthEstimatorType bwe_type);
80   void RunSelfFairness(BandwidthEstimatorType bwe_type);
81   void RunRoundTripTimeFairness(BandwidthEstimatorType bwe_type);
82   void RunLongTcpFairness(BandwidthEstimatorType bwe_type);
83   void RunMultipleShortTcpFairness(BandwidthEstimatorType bwe_type,
84                                    std::vector<int> tcp_file_sizes_bytes,
85                                    std::vector<int64_t> tcp_starting_times_ms);
86   void RunPauseResumeFlows(BandwidthEstimatorType bwe_type);
87 
88   void RunFairnessTest(BandwidthEstimatorType bwe_type,
89                        size_t num_media_flows,
90                        size_t num_tcp_flows,
91                        int64_t run_time_seconds,
92                        uint32_t capacity_kbps,
93                        int64_t max_delay_ms,
94                        int64_t rtt_ms,
95                        int64_t max_jitter_ms,
96                        const int64_t* offsets_ms);
97 
98   void RunFairnessTest(BandwidthEstimatorType bwe_type,
99                        size_t num_media_flows,
100                        size_t num_tcp_flows,
101                        int64_t run_time_seconds,
102                        uint32_t capacity_kbps,
103                        int64_t max_delay_ms,
104                        int64_t rtt_ms,
105                        int64_t max_jitter_ms,
106                        const int64_t* offsets_ms,
107                        const std::string& title,
108                        const std::string& flow_name);
109 
110   static std::vector<int> GetFileSizesBytes(int num_files);
111   static std::vector<int64_t> GetStartingTimesMs(int num_files);
112 
113  protected:
114   void SetUp();
115 
116   void VerboseLogging(bool enable);
117   void RunFor(int64_t time_ms);
118   std::string GetTestName() const;
119 
120   void PrintResults(double max_throughput_kbps,
121                     Stats<double> throughput_kbps,
122                     int flow_id,
123                     Stats<double> flow_delay_ms,
124                     Stats<double> flow_throughput_kbps);
125 
126   void PrintResults(double max_throughput_kbps,
127                     Stats<double> throughput_kbps,
128                     std::map<int, Stats<double>> flow_delay_ms,
129                     std::map<int, Stats<double>> flow_throughput_kbps);
130 
131   Link downlink_;
132   Link uplink_;
133 
134  private:
135   void FindPacketsToProcess(const FlowIds& flow_ids, Packets* in,
136                             Packets* out);
137   void GiveFeedbackToAffectedSenders(PacketReceiver* receiver);
138 
139   int64_t run_time_ms_;
140   int64_t time_now_ms_;
141   int64_t simulation_interval_ms_;
142   std::vector<Link*> links_;
143   Packets packets_;
144   bool plot_total_available_capacity_;
145 
146   RTC_DISALLOW_COPY_AND_ASSIGN(BweTest);
147 };
148 
149 // Default Evaluation parameters:
150 // Link capacity: 4000ms;
151 // Queueing delay capacity: 300ms.
152 // One-Way propagation delay: 50ms.
153 // Jitter model: Truncated gaussian.
154 // Maximum end-to-end jitter: 30ms = 2*standard_deviation.
155 // Bottleneck queue type: Drop tail.
156 // Path loss ratio: 0%.
157 
158 const int kOneWayDelayMs = 50;
159 const int kMaxQueueingDelayMs = 300;
160 const int kMaxCapacityKbps = 4000;
161 const int kMaxJitterMs = 15;
162 
163 struct DefaultEvaluationFilter {
DefaultEvaluationFilterDefaultEvaluationFilter164   DefaultEvaluationFilter(PacketProcessorListener* listener, int flow_id)
165       : choke(listener, flow_id),
166         delay(listener, flow_id),
167         jitter(listener, flow_id) {
168     SetDefaultParameters();
169   }
170 
DefaultEvaluationFilterDefaultEvaluationFilter171   DefaultEvaluationFilter(PacketProcessorListener* listener,
172                           const FlowIds& flow_ids)
173       : choke(listener, flow_ids),
174         delay(listener, flow_ids),
175         jitter(listener, flow_ids) {
176     SetDefaultParameters();
177   }
178 
SetDefaultParametersDefaultEvaluationFilter179   void SetDefaultParameters() {
180     delay.SetOneWayDelayMs(kOneWayDelayMs);
181     choke.set_max_delay_ms(kMaxQueueingDelayMs);
182     choke.set_capacity_kbps(kMaxCapacityKbps);
183     jitter.SetMaxJitter(kMaxJitterMs);
184   }
185 
186   ChokeFilter choke;
187   DelayFilter delay;
188   JitterFilter jitter;
189 };
190 
191 }  // namespace bwe
192 }  // namespace testing
193 }  // namespace webrtc
194 
195 #endif  // WEBRTC_MODULES_REMOTE_BITRATE_ESTIMATOR_TEST_BWE_TEST_H_
196