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_preserved_elements = received_packets_.size() / 10;
+  PacketNodeIt it = received_packets_.begin();
+  std::advance(it, num_preserved_elements);
+
+  while (it != received_packets_.end()) {
+    received_packets_.Erase(it++);
+  }
+
+  // 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();
+   map_.erase(list_.back()->sequence_number);
+   list_.pop_back();
 }
 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;

[stefan-webrtc, 2015/07/06 08:24:51]

Mostly as an FYI (no need to change):
In jitter_buffer.h/.cc I solved this type of problem by overriding the
comparison for the map and taking wrap arounds into account in there. Not sure
if that would work for you at all, but it looks like this:


class TimestampLessThan {
 public:
  bool operator() (uint32_t timestamp1,
                   uint32_t timestamp2) const {
    return IsNewerTimestamp(timestamp2, timestamp1);
  }
};

std::map<uint32_t, VCMFrameBuffer*, TimestampLessThan>

[magalhaesc, 2015/07/06 11:19:37]

Thanks, good suggestion.

+  }
+}
+
+void LinkedSet::Erase(PacketNodeIt node_rit) {
+  map_.erase((*node_rit)->sequence_number);
+  list_.erase(node_rit);
+}
+
+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