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.
  */
 
@@ skipping 11 matching lines @@
 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;
 
 BweReceiver::BweReceiver(int flow_id)
-    : flow_id_(flow_id), received_packets_(kSetCapacity) {
+    : flow_id_(flow_id), received_packets_(kSetCapacity), loss_account() {
+}
+
+void BweSender::Pause() {
+  running_ = false;
+}
+
+void BweSender::Resume() {
+  running_ = true;
 }
 
 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() {
+// Take into account all LinkedSet content.
+void BweReceiver::UpdateLoss() {
+  loss_account.Add(LinkedSetPacketLossRatio());
+}
+
+void BweReceiver::ClearSet() {
+  received_packets_.Clear();
+}
+
+// Preserve 10% latest packets and update packet loss based on the oldest
+// 90%, that will be removed.
+void BweReceiver::RelieveSetAndUpdateLoss() {
+  // Compute Loss for the whole LinkedSet and updates loss_account_.
+  UpdateLoss();
+
+  size_t num_deleted_elements = (9 * received_packets_.size()) / 10;

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

num_elements_to_delete

[magalhaesc, 2015/07/03 11:55:12]

Done.

+
+  for (PacketNodeIt it = --received_packets_.end(); num_deleted_elements > 0;
+       --it) {
+    received_packets_.Erase(it);

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

This is still a fairly slow way of doing the erase, since you will have to do a
logarithmic lookup in your map for every element, even though they likely are in
a sequence. You could do it like this instead:

received_packets_.EraseOldPackets(num_elements_to_delete);

And in that method you first erase all packets from the list, and record the
last sequence number you have erased (last_erased_seq_num). Then you do a find
on the map on that sequence number and erase from there:
it = map.find(last_erased_seq_num);
map.erase(it, it + num_elements_to_erase);

I at least _think_ that should work. Makes the erase n + log(n) instead of
n*log(n).

Not sure if it's worth doing?

[magalhaesc, 2015/07/03 11:55:13]

Kept with the map lookup for every list element to be removed due to possible
disarrangement on packets arrivals.

+    --num_deleted_elements;
+  }
+
+  // Compute Loss for the preserved elements
+  loss_account.Subtract(LinkedSetPacketLossRatio());
+}
+
+float BweReceiver::GlobalReceiverPacketLossRatio() {
+  UpdateLoss();
+  return loss_account.LossRatio();
+}
+
+// This function considers at most kSetCapacity = 1000 packets.
+LossAccount BweReceiver::LinkedSetPacketLossRatio() {
   if (received_packets_.empty()) {
-    return 0.0f;
+    return LossAccount();
   }
-  // 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;
+  uint16_t oldest_seq_num = received_packets_.OldestSeqNumber();
+  uint16_t newest_seq_num = received_packets_.NewestSeqNumber();
+
+  size_t set_total_packets =
+      static_cast<uint16_t>(newest_seq_num - oldest_seq_num + 1);
+
+  size_t set_received_packets = received_packets_.size();
+  size_t set_lost_packets = set_total_packets - set_received_packets;
+
+  return LossAccount(set_total_packets, set_lost_packets);
+}
+
+uint32_t BweReceiver::RecentKbps() {
+  return (rate_counter_.bits_per_second() + 500) / 1000;
 }
 
 // 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;
   }
   int number_packets_received = 0;
 
   PacketNodeIt node_it = received_packets_.begin();  // Latest.
 
   // Lowest timestamp limit, oldest one that should be checked.
   int64_t time_limit_ms = (*node_it)->arrival_time_ms - kPacketLossTimeWindowMs;
   // Oldest and newest values found within the given time window.
-  uint16_t oldest_seq_nb = (*node_it)->sequence_number;
-  uint16_t newest_seq_nb = oldest_seq_nb;
+  uint16_t oldest_seq_num = (*node_it)->sequence_number;
+  uint16_t newest_seq_num = oldest_seq_num;
 
   while (node_it != received_packets_.end()) {
     if ((*node_it)->arrival_time_ms < time_limit_ms) {
       break;
     }
     uint16_t seq_nb = (*node_it)->sequence_number;
-    if (IsNewerSequenceNumber(seq_nb, newest_seq_nb)) {
-      newest_seq_nb = seq_nb;
+    if (IsNewerSequenceNumber(seq_nb, newest_seq_num)) {
+      newest_seq_num = seq_nb;
     }
-    if (IsNewerSequenceNumber(oldest_seq_nb, seq_nb)) {
-      oldest_seq_nb = seq_nb;
+    if (IsNewerSequenceNumber(oldest_seq_num, seq_nb)) {
+      oldest_seq_num = seq_nb;
     }
     ++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);
+  // There was an overflow if newest_seq_num < oldest_seq_num.
+  int gap = static_cast<uint16_t>(newest_seq_num - oldest_seq_num + 1);
 
   return static_cast<float>(gap - number_packets_received) / gap;
 }
 
 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()) {
       list_.erase(node_it);
       list_.push_front(node);
       map_[sequence_number] = list_.begin();
     }
   } else {
     if (size() == capacity_) {
       RemoveTail();
     }
     UpdateHead(new PacketIdentifierNode(sequence_number, send_time_ms,
                                         arrival_time_ms, payload_size));
   }
 }
+
+void LinkedSet::Insert(PacketIdentifierNode packet_identifier) {
+  Insert(packet_identifier.sequence_number, packet_identifier.send_time_ms,
+         packet_identifier.arrival_time_ms, packet_identifier.payload_size);
+}
+
 void LinkedSet::RemoveTail() {
-  map_.erase(list_.back()->sequence_number);
-  list_.pop_back();
+  Erase(--end());
 }
 void LinkedSet::UpdateHead(PacketIdentifierNode* new_head) {
   list_.push_front(new_head);
   map_[new_head->sequence_number] = list_.begin();
 }
 
+uint16_t LinkedSet::OldestSeqNumber() {
+  if (IsNewerSequenceNumber(Max(), Min()) || Max() == Min()) {
+    return Min();  // An empty set will return Max = Min = 0.
+  } else {         // There was an overflow.
+    return map_.lower_bound(0x8000)->first;
+  }
+}
+
+uint16_t LinkedSet::NewestSeqNumber() {
+  if (IsNewerSequenceNumber(Max(), Min()) || Max() == Min()) {
+    return Max();  // An empty set will return Max = Min = 0.
+  } else {         // There was an overflow.
+    return (--map_.lower_bound(0x8000))->first;
+  }
+}
+
+void LinkedSet::Erase(PacketNodeIt node_it) {
+  map_.erase((*node_it)->sequence_number);
+  list_.erase(node_it);
+}
+
+void LossAccount::Add(LossAccount rhs) {
+  num_total += rhs.num_total;
+  num_lost += rhs.num_lost;
+}
+void LossAccount::Subtract(LossAccount rhs) {
+  num_total -= rhs.num_total;
+  num_lost -= rhs.num_lost;
+}
+
+float LossAccount::LossRatio() {
+  return static_cast<float>(num_lost) / num_total;
+}
+
 }  // namespace bwe
 }  // namespace testing
 }  // namespace webrtc