More Simulation Framework features

webrtc/modules/remote_bitrate_estimator/test/bwe.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.
  */
 
 #include "webrtc/modules/remote_bitrate_estimator/test/bwe.h"
 
 #include <limits>
 
 #include "webrtc/base/common.h"
 #include "webrtc/modules/remote_bitrate_estimator/test/estimators/nada.h"
 #include "webrtc/modules/remote_bitrate_estimator/test/estimators/remb.h"
 #include "webrtc/modules/remote_bitrate_estimator/test/estimators/send_side.h"
 #include "webrtc/modules/remote_bitrate_estimator/test/estimators/tcp.h"
 
 namespace webrtc {
 namespace testing {
 namespace bwe {
 
 // With the assumption that packet loss is lower than 97%, the max gap
 // between elements in the set is lower than 0x8000, hence we have a
 // total order in the set. For (x,y,z) subset of the LinkedSet,
 // (x<=y and y<=z) ==> x<=z so the set can be sorted.
 const int kSetCapacity = 1000;

[magalhaesc, 2015/06/25 11:09:16]

2 options:

-- Replace 1000 with 1000, then recalculate the 97% value

or

-- Keep 1000, then replace 10000 with 1000 on comment line 133/

[stefan-webrtc, 2015/06/25 14:44:03]

Right... I would personally prefer if we could have a smaller history here. It
would be doable by having an accumulated loss rate that we update whenever the
history becomes full. Then we can remove an item every time we add an item (when
we have filled the history), and update the global loss rate with the removed
item. WDYT?

[magalhaesc, 2015/07/01 12:48:39]

All right, I will keep it 1000. 
What do you think about a implementation in between clearing all packets and the
one dropping just the tail? 
I was thinking about preserving, let's say 10%=100 packets, calculate the packet
loss over the other 900 that will be deleted, and then update loss account

 
 BweReceiver::BweReceiver(int flow_id)
-    : flow_id_(flow_id), received_packets_(kSetCapacity) {
+    : num_previous_total_packets_(0),
+      num_previous_lost_packets_(0),
+      flow_id_(flow_id),
+      received_packets_(kSetCapacity) {
+}
+
+void BweSender::Pause() {
+  running_ = false;
+  bitrate_kbps_ = 0;
+}
+
+void BweSender::Resume() {
+  running_ = true;
+  bitrate_kbps_ = kMinBitrateKbps;
 }
 
 class NullBweSender : public BweSender {
  public:
   NullBweSender() {}
   virtual ~NullBweSender() {}
 
   int GetFeedbackIntervalMs() const override { return 1000; }
   void GiveFeedback(const FeedbackPacket& feedback) override {}
   void OnPacketsSent(const Packets& packets) override {}
@@ skipping 47 matching lines @@
       return new NadaBweReceiver(flow_id);
     case kTcpEstimator:
       return new TcpBweReceiver(flow_id);
     case kNullEstimator:
       return new BweReceiver(flow_id);
   }
   assert(false);
   return NULL;
 }
 
-float BweReceiver::GlobalPacketLossRatio() {
+void BweReceiver::UpdateLossAccount() {
+  float set_loss_ratio = LinkedSetPacketLossRatio();
+  size_t set_received_packets = received_packets_.size();
+  size_t set_total_packets = set_received_packets / (1.0f - set_loss_ratio);
+  size_t set_lost_packets = set_total_packets - set_received_packets;
+
+  num_previous_total_packets_ += static_cast<uint32_t>(set_total_packets);
+  num_previous_lost_packets_ += static_cast<uint32_t>(set_lost_packets);
+}

[stefan-webrtc, 2015/06/25 14:44:03]

But if this method gets called whenever we remove packets it should all be fine
for the global loss ratio right?

[magalhaesc, 2015/07/01 12:48:39]

Yes, all should be fine for the global loss ratio (we were using it to plot loss
histograms)

The UpdateLoss() should anyway be called in GlobalReceiverPacketLossRatio() in
order to compute remaining packets in the LinkedSet that weren't deleted.

+
+void BweReceiver::ClearSet() {
+  received_packets_.Clear();
+}
+
+float BweReceiver::GlobalReceiverPacketLossRatio() {
+  UpdateLossAccount();
+  return static_cast<float>(num_previous_lost_packets_) /
+         num_previous_total_packets_;
+}
+
+// This function considers at most kSetCapacity = 10000 packets.
+// TODO(magalhaesc): Unwrap sequence number to handle more.
+float BweReceiver::LinkedSetPacketLossRatio() {
   if (received_packets_.empty()) {
     return 0.0f;
   }
   // Possibly there are packets missing.
   const uint16_t kMaxGap = 1.5 * kSetCapacity;
   uint16_t min = received_packets_.find_min();
   uint16_t max = received_packets_.find_max();
 
   int gap;
   if (max - min < kMaxGap) {
     gap = max - min + 1;
   } else {  // There was an overflow.
     max = received_packets_.upper_bound(kMaxGap);
     min = received_packets_.lower_bound(0xFFFF - kMaxGap);
     gap = max + (0xFFFF - min) + 2;
   }
-  return static_cast<float>(received_packets_.size()) / gap;
+  return static_cast<float>(gap - received_packets_.size()) / gap;
 }
 
 // Go through a fixed time window of most recent packets received and
 // counts packets missing to obtain the packet loss ratio. If an unordered
 // packet falls out of the timewindow it will be counted as missing.
 // E.g.: for a timewindow covering 5 packets of the following arrival sequence
 // {10 7 9 5 6} 8 3 2 4 1, the output will be 1/6 (#8 is considered as missing).
 float BweReceiver::RecentPacketLossRatio() {
   if (received_packets_.empty()) {
     return 0.0f;
@@ skipping 22 matching lines @@
     ++node_it;
     ++number_packets_received;
   }
   // Interval width between oldest and newest sequence number.
   // There was an overflow if newest_seq_nb < oldest_seq_nb.
   int gap = static_cast<uint16_t>(newest_seq_nb - oldest_seq_nb + 1);
 
   return static_cast<float>(gap - number_packets_received) / gap;
 }
 
+// For a given time window, compute the receiving speed rate in kbps.
+// As described below, three cases are considered depending on the number of
+// packets received.
+size_t BweReceiver::RecentReceivingRate() {

[magalhaesc, 2015/06/25 09:03:35]

Since a RateCounter was added, RecentReceivingRate will be removed.

+  // If the receiver didn't receive any packet, return 0.
+  if (received_packets_.empty()) {
+    return 0.0f;
+  }
+  size_t total_size = 0;
+  int number_packets = 0;
+
+  PacketNodeIt node_it = received_packets_.begin();
+
+  int64_t last_time_ms = (*node_it)->arrival_time_ms;
+  int64_t start_time_ms = last_time_ms;
+  PacketNodeIt end = received_packets_.end();
+
+  // Stops after including the first packet out of the timeWindow.
+  // Ameliorates results when there are wide gaps between packets.
+  // E.g. Large packets : p1(0ms), p2(3000ms).
+  while (node_it != end) {
+    total_size += (*node_it)->payload_size;
+    last_time_ms = (*node_it)->arrival_time_ms;
+    ++number_packets;
+    if ((*node_it)->arrival_time_ms <
+        start_time_ms - kReceivingRateTimeWindowMs) {
+      break;
+    }
+    ++node_it;
+  }
+
+  int64_t corrected_time_ms;
+  // If the receiver didn't receive enough packets to fill the time window:
+  if (start_time_ms - last_time_ms < kReceivingRateTimeWindowMs) {
+    corrected_time_ms = kReceivingRateTimeWindowMs;
+  }
+  // If the receiver received multiple packets, use as time interval the gap
+  // between first and last packet falling in the timeWindow corrected by the
+  // factor number_packets/(number_packets-1).
+  // E.g: Let timeWindow = 500ms, payload_size = 500 bytes, number_packets = 2,
+  // packets received at t1(0ms) and t2(499 or 501ms). This prevent the function
+  // from returning ~2*8, sending instead a more likely ~1*8 kbps.
+  else {
+    corrected_time_ms = (number_packets * (start_time_ms - last_time_ms)) /
+                        (number_packets - 1);
+  }
+
+  // Converting from bytes/ms to kbits/s.
+  return static_cast<size_t>(8 * total_size / corrected_time_ms);
+}

[stefan-webrtc, 2015/06/25 14:44:03]

This method seems overly complicated to me. I would prefer it if we implemented
this using the RateCounter instead.

[magalhaesc, 2015/07/01 12:48:39]

Right, this method will be removed.

+
 void LinkedSet::Insert(uint16_t sequence_number,
                        int64_t send_time_ms,
                        int64_t arrival_time_ms,
                        size_t payload_size) {
   std::map<uint16_t, PacketNodeIt>::iterator it = map_.find(sequence_number);
   if (it != map_.end()) {
     PacketNodeIt node_it = it->second;
     PacketIdentifierNode* node = *node_it;
     node->arrival_time_ms = arrival_time_ms;
     if (node_it != list_.begin()) {
@@ skipping 14 matching lines @@
   list_.pop_back();
 }
 void LinkedSet::UpdateHead(PacketIdentifierNode* new_head) {
   list_.push_front(new_head);
   map_[new_head->sequence_number] = list_.begin();
 }
 
 }  // namespace bwe
 }  // namespace testing
 }  // namespace webrtc