More Simulation Framework features

webrtc/modules/remote_bitrate_estimator/test/bwe_test_framework.h

 /*
  *  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.
  */
 
 #ifndef WEBRTC_MODULES_REMOTE_BITRATE_ESTIMATOR_TEST_BWE_TEST_FRAMEWORK_H_
 #define WEBRTC_MODULES_REMOTE_BITRATE_ESTIMATOR_TEST_BWE_TEST_FRAMEWORK_H_
 
 #include <assert.h>
 #include <math.h>
 
 #include <algorithm>
 #include <list>
 #include <numeric>
 #include <sstream>
 #include <string>
 #include <vector>
 
+#include "webrtc/base/common.h"
 #include "webrtc/base/scoped_ptr.h"
 #include "webrtc/modules/bitrate_controller/include/bitrate_controller.h"
 #include "webrtc/modules/interface/module_common_types.h"
 #include "webrtc/modules/pacing/include/paced_sender.h"
 #include "webrtc/modules/remote_bitrate_estimator/include/remote_bitrate_estimator.h"
 #include "webrtc/modules/remote_bitrate_estimator/test/bwe_test_logging.h"
 #include "webrtc/modules/remote_bitrate_estimator/test/packet.h"
 #include "webrtc/modules/remote_bitrate_estimator/test/random.h"
 #include "webrtc/modules/rtp_rtcp/interface/rtp_rtcp_defines.h"
 #include "webrtc/system_wrappers/interface/clock.h"
 
 namespace webrtc {
 
 class RtcpBandwidthObserver;
 
 namespace testing {
 namespace bwe {
 
 class DelayCapHelper;
-class RateCounter;
+
+class RateCounter {
+ public:
+  RateCounter(int64_t window_size_ms)
+      : window_size_us_(1000 * window_size_ms),
+        recently_received_packets_(0),
+        recently_received_bytes_(0),
+        last_accumulated_us_(0),
+        window_() {}
+
+  RateCounter() : RateCounter(1000) {}
+
+  void UpdateRates(int64_t send_time_us, uint32_t payload_size);
+
+  int64_t window_size_ms() const { return window_size_us_ / 1000; }
+  uint32_t packets_per_second() const;
+  uint32_t bits_per_second() const;
+
+  double BitrateWindowS() const;
+
+ private:
+  typedef std::pair<int64_t, uint32_t> TimeSizePair;
+
+  int64_t window_size_us_;
+  uint32_t recently_received_packets_;
+  uint32_t recently_received_bytes_;
+  int64_t last_accumulated_us_;
+  std::list<TimeSizePair> window_;
+};
 
 typedef std::set<int> FlowIds;
 const FlowIds CreateFlowIds(const int *flow_ids_array, size_t num_flow_ids);
+const FlowIds CreateFlowIdRange(int initial_value, int last_value);
 
 template <typename T>
 bool DereferencingComparator(const T* const& a, const T* const& b) {
   assert(a != NULL);
   assert(b != NULL);
   return *a < *b;
 }
 
 template<typename T> class Stats {
  public:
@@ skipping 79 matching lines @@
   std::vector<T> data_;
   typename std::vector<T>::size_type last_mean_count_;
   typename std::vector<T>::size_type last_variance_count_;
   typename std::vector<T>::size_type last_minmax_count_;
   T mean_;
   T variance_;
   T min_;
   T max_;
 };
 
+class Random {
+ public:
+  explicit Random(uint32_t seed);
+
+  // Return pseudo random number in the interval [0.0, 1.0].
+  float Rand();
+
+  // Return pseudo rounded random number in interval [low, high].
+  int Rand(int low, int high);
+
+  // Normal Distribution.
+  int Gaussian(int mean, int standard_deviation);
+
+  // Exponential Distribution.
+  int Exponential(float lambda);
+
+  // TODO(solenberg): Random from histogram.
+  // template<typename T> int Distribution(const std::vector<T> histogram) {
+
+ private:
+  uint32_t a_;
+  uint32_t b_;
+
+  DISALLOW_IMPLICIT_CONSTRUCTORS(Random);
+};
+
 bool IsTimeSorted(const Packets& packets);
 
 class PacketProcessor;
 
 enum ProcessorType { kSender, kReceiver, kRegular };
 
 class PacketProcessorListener {
  public:
   virtual ~PacketProcessorListener() {}
 
@@ skipping 16 matching lines @@
   // internal data.
   virtual void Plot(int64_t timestamp_ms) {}
 
   // Run simulation for |time_ms| milliseconds, consuming packets from, and
   // producing packets into in_out. The outgoing packet list must be sorted on
   // |send_time_us_|. The simulation time |time_ms| is optional to use.
   virtual void RunFor(int64_t time_ms, Packets* in_out) = 0;
 
   const FlowIds& flow_ids() const { return flow_ids_; }
 
+  uint32_t packets_per_second() const;
+  uint32_t bits_per_second() const;
+
+ protected:
+  RateCounter rate_counter_;
+
  private:
   PacketProcessorListener* listener_;
   const FlowIds flow_ids_;
 
   DISALLOW_COPY_AND_ASSIGN(PacketProcessor);
 };
 
 class RateCounterFilter : public PacketProcessor {
  public:
   RateCounterFilter(PacketProcessorListener* listener,
                     int flow_id,
                     const char* name);
   RateCounterFilter(PacketProcessorListener* listener,
                     const FlowIds& flow_ids,
                     const char* name);
+  RateCounterFilter(PacketProcessorListener* listener,
+                    const FlowIds& flow_ids,
+                    const char* name,
+                    int64_t start_plotting_time_ms);
   virtual ~RateCounterFilter();
 
-  uint32_t packets_per_second() const;
-  uint32_t bits_per_second() const;
-
   void LogStats();
   Stats<double> GetBitrateStats() const;
   virtual void Plot(int64_t timestamp_ms);
   virtual void RunFor(int64_t time_ms, Packets* in_out);
 
  private:
-  rtc::scoped_ptr<RateCounter> rate_counter_;
   Stats<double> packets_per_second_stats_;
   Stats<double> kbps_stats_;
   std::string name_;
+  int64_t start_plotting_time_ms_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(RateCounterFilter);
 };
 
 class LossFilter : public PacketProcessor {
  public:
   LossFilter(PacketProcessorListener* listener, int flow_id);
   LossFilter(PacketProcessorListener* listener, const FlowIds& flow_ids);
   virtual ~LossFilter() {}
 
   void SetLoss(float loss_percent);
   virtual void RunFor(int64_t time_ms, Packets* in_out);
 
  private:
   Random random_;
   float loss_fraction_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(LossFilter);
 };
 
 class DelayFilter : public PacketProcessor {
  public:
   DelayFilter(PacketProcessorListener* listener, int flow_id);
   DelayFilter(PacketProcessorListener* listener, const FlowIds& flow_ids);
   virtual ~DelayFilter() {}
 
-  void SetDelayMs(int64_t delay_ms);
+  void SetOneWayDelayMs(int64_t one_way_delay_ms);
   virtual void RunFor(int64_t time_ms, Packets* in_out);
 
  private:
-  int64_t delay_us_;
+  int64_t one_way_delay_us_;
   int64_t last_send_time_us_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(DelayFilter);
 };
 
 class JitterFilter : public PacketProcessor {
  public:
   JitterFilter(PacketProcessorListener* listener, int flow_id);
   JitterFilter(PacketProcessorListener* listener, const FlowIds& flow_ids);
   virtual ~JitterFilter() {}
@@ skipping 26 matching lines @@
   DISALLOW_IMPLICIT_CONSTRUCTORS(ReorderFilter);
 };
 
 // Apply a bitrate choke with an infinite queue on the packet stream.
 class ChokeFilter : public PacketProcessor {
  public:
   ChokeFilter(PacketProcessorListener* listener, int flow_id);
   ChokeFilter(PacketProcessorListener* listener, const FlowIds& flow_ids);
   virtual ~ChokeFilter();
 
-  void SetCapacity(uint32_t kbps);
-  void SetMaxDelay(int max_delay_ms);
+  void set_capacity_kbps(uint32_t kbps);
+  void set_max_delay_ms(int64_t max_queueing_delay_ms);
+
+  uint32_t capacity_kbps();
+
   virtual void RunFor(int64_t time_ms, Packets* in_out);
 
   Stats<double> GetDelayStats() const;
 
  private:
-  uint32_t kbps_;
+  uint32_t capacity_kbps_;
   int64_t last_send_time_us_;
   rtc::scoped_ptr<DelayCapHelper> delay_cap_helper_;
+  int64_t max_delay_us_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(ChokeFilter);
 };
 
 class TraceBasedDeliveryFilter : public PacketProcessor {
  public:
   TraceBasedDeliveryFilter(PacketProcessorListener* listener, int flow_id);
   TraceBasedDeliveryFilter(PacketProcessorListener* listener,
                            const FlowIds& flow_ids);
   TraceBasedDeliveryFilter(PacketProcessorListener* listener,
                            int flow_id,
                            const char* name);
   virtual ~TraceBasedDeliveryFilter();
 
   // The file should contain nanosecond timestamps corresponding to the time
   // when the network can accept another packet. The timestamps should be
   // separated by new lines, e.g., "100000000\n125000000\n321000000\n..."
   bool Init(const std::string& filename);
   virtual void Plot(int64_t timestamp_ms);
   virtual void RunFor(int64_t time_ms, Packets* in_out);
 
-  void SetMaxDelay(int max_delay_ms);
+  void set_max_delay_ms(int64_t max_delay_ms);
   Stats<double> GetDelayStats() const;
   Stats<double> GetBitrateStats() const;
 
  private:
   void ProceedToNextSlot();
 
   typedef std::vector<int64_t> TimeList;
   int64_t current_offset_us_;
   TimeList delivery_times_us_;
   TimeList::const_iterator next_delivery_it_;
@@ skipping 15 matching lines @@
               uint32_t ssrc,
               int64_t first_frame_offset_ms);
   virtual ~VideoSource() {}
 
   virtual void RunFor(int64_t time_ms, Packets* in_out);
 
   virtual int flow_id() const { return flow_id_; }
   virtual void SetBitrateBps(int bitrate_bps) {}
   uint32_t bits_per_second() const { return bits_per_second_; }
   uint32_t max_payload_size_bytes() const { return kMaxPayloadSizeBytes; }
   int64_t GetTimeUntilNextFrameMs() const { return next_frame_ms_ - now_ms_; }

[stefan-webrtc, 2015/07/14 13:49:04]

Make sure this takes the randomization into account.

[magalhaesc, 2015/07/14 17:19:33]

Done.

 
  protected:
   virtual uint32_t NextFrameSize();
   virtual uint32_t NextPacketSize(uint32_t frame_size,
                                   uint32_t remaining_payload);
 
   const uint32_t kMaxPayloadSizeBytes;
   const uint32_t kTimestampBase;
   const double frame_period_ms_;
   uint32_t bits_per_second_;
   uint32_t frame_size_bytes_;
 
  private:
   const int flow_id_;
   int64_t next_frame_ms_;
   int64_t now_ms_;
   RTPHeader prototype_header_;
+  int64_t start_plotting_ms_;
+  uint32_t previous_bitrate_bps_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(VideoSource);
 };
 
 class AdaptiveVideoSource : public VideoSource {
  public:
   AdaptiveVideoSource(int flow_id,
                       float fps,
                       uint32_t kbps,
                       uint32_t ssrc,
@@ skipping 26 matching lines @@
   uint32_t frame_counter_;
   int compensation_bytes_;
   int compensation_per_frame_;
   DISALLOW_IMPLICIT_CONSTRUCTORS(PeriodicKeyFrameSource);
 };
 }  // namespace bwe
 }  // namespace testing
 }  // namespace webrtc
 
 #endif  // WEBRTC_MODULES_REMOTE_BITRATE_ESTIMATOR_TEST_BWE_TEST_FRAMEWORK_H_