More Simulation Framework features

webrtc/modules/remote_bitrate_estimator/test/bwe.h

 /*
  *  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.
  */
 
 #ifndef WEBRTC_MODULES_REMOTE_BITRATE_ESTIMATOR_TEST_BWE_H_
 #define WEBRTC_MODULES_REMOTE_BITRATE_ESTIMATOR_TEST_BWE_H_
 
 #include <sstream>
 
 #include "webrtc/modules/remote_bitrate_estimator/test/packet.h"
 #include "webrtc/modules/bitrate_controller/include/bitrate_controller.h"
+#include "webrtc/modules/remote_bitrate_estimator/test/bwe_test_framework.h"
 
 namespace webrtc {
 namespace testing {
 namespace bwe {
 
 // Holds only essential information about packets to be saved for
 // further use, e.g. for calculating packet loss and receiving rate.
 struct PacketIdentifierNode {
   PacketIdentifierNode(uint16_t sequence_number,
                        int64_t send_time_ms,
                        int64_t arrival_time_ms,
                        size_t payload_size)
       : sequence_number(sequence_number),
         send_time_ms(send_time_ms),
         arrival_time_ms(arrival_time_ms),
         payload_size(payload_size) {}
 
+  PacketIdentifierNode copy();

[stefan-webrtc, 2015/07/02 11:03:41]

Not sure why this is needed. You can simply use the copy constructor.

[magalhaesc, 2015/07/02 17:06:18]

Done.

+
   uint16_t sequence_number;
   int64_t send_time_ms;
   int64_t arrival_time_ms;
   size_t payload_size;
 };
 
 typedef std::list<PacketIdentifierNode*>::iterator PacketNodeIt;
 
 // FIFO implementation for a limited capacity set.
 // Used for keeping the latest arrived packets while avoiding duplicates.
 // Allows efficient insertion, deletion and search.
 class LinkedSet {
  public:
   explicit LinkedSet(int capacity) : capacity_(capacity) {}
 
   // If the arriving packet (identified by its sequence number) is already
   // in the LinkedSet, move its Node to the head of the list. Else, create
   // a PacketIdentifierNode n_ and then UpdateHead(n_), calling RemoveTail()
   // if the LinkedSet reached its maximum capacity.
   void Insert(uint16_t sequence_number,
               int64_t send_time_ms,
               int64_t arrival_time_ms,
               size_t payload_size);
 
+  void Insert(PacketIdentifierNode packet_identifier);
+
   PacketNodeIt begin() { return list_.begin(); }
   PacketNodeIt end() { return list_.end(); }
   bool empty() { return list_.empty(); }
   size_t size() { return list_.size(); }
-  // Gets the latest arrived sequence number.
-  uint16_t find_max() { return map_.rbegin()->first; }
-  // Gets the first arrived sequence number still saved in the LinkedSet.
-  uint16_t find_min() { return map_.begin()->first; }
-  // Gets the lowest saved sequence number that is >= than the input key.
-  uint16_t lower_bound(uint16_t key) { return map_.lower_bound(key)->first; }
-  // Gets the highest saved sequence number that is <= than the input key.
-  uint16_t upper_bound(uint16_t key) { return map_.upper_bound(key)->first; }
   size_t capacity() { return capacity_; }
 
+  // Gets the highest (absolute value) sequence number.
+  uint16_t Max() { return empty() ? 0 : map_.rbegin()->first; }
+  // Gets the lowest (absolute value) sequence number still saved in the
+  // LinkedSet.
+  uint16_t Min() { return empty() ? 0 : map_.begin()->first; }
+
+  uint16_t OldestSeqNumber();
+  uint16_t NewestSeqNumber();
+
+  void Clear() {
+    map_.clear();
+    list_.clear();
+  }
+
  private:
   // Pop oldest element from the back of the list and remove it from the map.
   void RemoveTail();
   // Add new element to the front of the list and insert it in the map.
   void UpdateHead(PacketIdentifierNode* new_head);
   size_t capacity_;
   std::map<uint16_t, PacketNodeIt> map_;
   std::list<PacketIdentifierNode*> list_;
 };
 
+// Holds information for computing global packet loss.
+struct LossAccount {
+  LossAccount() : num_total(0), num_lost(0) {}
+  LossAccount(uint32_t num_total, uint32_t num_lost)
+      : num_total(num_total), num_lost(num_lost) {}
+  void Add(LossAccount addend);
+  void Subtract(LossAccount subtrahend);

[stefan-webrtc, 2015/07/02 11:03:41]

Switch addend and subtrahend to "loss" or "rhs" (right hand side) or something.

[magalhaesc, 2015/07/02 17:06:18]

Done.

+  float LossRatio();
+  uint32_t num_total;
+  uint32_t num_lost;
+};
+
 const int kMinBitrateKbps = 150;
-const int kMaxBitrateKbps = 3000;
+const int kMaxBitrateKbps = 1500;

[stefan-webrtc, 2015/07/02 11:03:41]

Should make these 30 / 2500, right?

[magalhaesc, 2015/07/02 17:06:18]

right

 
 class BweSender : public Module {
  public:
-  BweSender() {}
+  BweSender() : running_(true) {}
   virtual ~BweSender() {}
 
   virtual int GetFeedbackIntervalMs() const = 0;
   virtual void GiveFeedback(const FeedbackPacket& feedback) = 0;
   virtual void OnPacketsSent(const Packets& packets) = 0;
+  virtual void Pause();
+  virtual void Resume();
+
+ protected:
+  bool running_;
+  int bitrate_kbps_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(BweSender);
 };
 
 class BweReceiver {
  public:
   explicit BweReceiver(int flow_id);
   virtual ~BweReceiver() {}
 
   virtual void ReceivePacket(int64_t arrival_time_ms,
                              const MediaPacket& media_packet) {}
   virtual FeedbackPacket* GetFeedback(int64_t now_ms) { return NULL; }
 
-  float GlobalPacketLossRatio();
-  float RecentPacketLossRatio();
   size_t GetSetCapacity() { return received_packets_.capacity(); }
 
+  uint32_t RecentKbps();  // Receiving Rate calculated over latest 1000ms.
+  // Packet loss only for packets arriving in the latest 500ms time window.
+  float RecentPacketLossRatio();  // Plot dynamics.
+  // Computes packet loss during an entire simulation, up to 4 billion packets.
+  float GlobalReceiverPacketLossRatio();  // Plot histogram.
+
   static const int64_t kPacketLossTimeWindowMs = 500;
+  static const int64_t kReceivingRateTimeWindowMs = 1000;

[stefan-webrtc, 2015/07/02 11:03:41]

Do these constants have to be public?

[magalhaesc, 2015/07/02 17:06:18]

We made them public to use on nada_unittests.cc
Do you think it's better to make them private and add get() methods?

[stefan-webrtc, 2015/07/03 09:32:10]

No, this is OK.

 
  protected:
+  void RelieveSetAndUpdateLoss();
   int flow_id_;
   // Deals with packets sent more than once.
   LinkedSet received_packets_;
+  // Used for calculating recent receiving rate.
+  RateCounter rate_counter_;
+
+ private:
+  void UpdateLoss();
+  void ClearSet();
+  // Packet loss for packets stored in the LinkedSet, up to 1000 packets.
+  // Used to update global loss account whenever the set is filled and cleared.
+  LossAccount LinkedSetPacketLossRatio();
+  // Used for calculating global packet loss ratio.
+  LossAccount loss_account;
 };
 
 enum BandwidthEstimatorType {
-  kNullEstimator,
+  kNullEstimator = 0,
   kNadaEstimator,
   kRembEstimator,
   kFullSendSideEstimator,
   kTcpEstimator
 };
 
+const std::string bwe_names[] = {"Null", "NADA", "REMB", "GCC", "TCP"};
+
 int64_t GetAbsSendTimeInMs(uint32_t abs_send_time);
 
 BweSender* CreateBweSender(BandwidthEstimatorType estimator,
                            int kbps,
                            BitrateObserver* observer,
                            Clock* clock);
 
 BweReceiver* CreateBweReceiver(BandwidthEstimatorType type,
                                int flow_id,
                                bool plot);
+
 }  // namespace bwe
 }  // namespace testing
 }  // namespace webrtc
 #endif  // WEBRTC_MODULES_REMOTE_BITRATE_ESTIMATOR_TEST_BWE_H_