More Simulation Framework features

webrtc/modules/remote_bitrate_estimator/test/bwe.cc

Index: webrtc/modules/remote_bitrate_estimator/test/bwe.cc
diff --git a/webrtc/modules/remote_bitrate_estimator/test/bwe.cc b/webrtc/modules/remote_bitrate_estimator/test/bwe.cc
index 6e8dbc7c068430905d2681508b10fb2af19fad31..56f63228e435b60c59e8d220630e747b6ff54a62 100644
--- a/webrtc/modules/remote_bitrate_estimator/test/bwe.cc
+++ b/webrtc/modules/remote_bitrate_estimator/test/bwe.cc
@@ -29,7 +29,20 @@ namespace bwe {
 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 {
@@ -97,7 +110,29 @@ BweReceiver* CreateBweReceiver(BandwidthEstimatorType type,
   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;
   }
@@ -114,7 +149,7 @@ float BweReceiver::GlobalPacketLossRatio() {
     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
@@ -157,6 +192,57 @@ float BweReceiver::RecentPacketLossRatio() {
   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,