Allow FakeNetworkPipe to drop packets in bursts.

webrtc/test/fake_network_pipe.cc

 /*
  *  Copyright (c) 2012 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 16 matching lines @@
 FakeNetworkPipe::FakeNetworkPipe(Clock* clock,
                                  const FakeNetworkPipe::Config& config,
                                  uint64_t seed)
     : clock_(clock),
       packet_receiver_(NULL),
       random_(seed),
       config_(config),
       dropped_packets_(0),
       sent_packets_(0),
       total_packet_delay_(0),
-      next_process_time_(clock_->TimeInMilliseconds()) {}
+      bursting_(false),
+      next_process_time_(clock_->TimeInMilliseconds()) {
+  prob_lose_next_ = (1.0 - 1.0 / config_.avg_burst_loss_length);
+  prob_burst_loss_ = (static_cast<double>(config_.loss_percent) /

[terelius, 2016/05/30 14:00:29]

This should probably be
config_.loss_percent / (1-config_.loss_percent) /
(config_.avg_burst_loss_length)
in order to lose on average config_.loss_percent packets.

[philipel, 2016/05/30 14:42:42]

Done.

+                      config_.avg_burst_loss_length) /
+                     100.0;
+}
 
 FakeNetworkPipe::~FakeNetworkPipe() {
   while (!capacity_link_.empty()) {
     delete capacity_link_.front();
     capacity_link_.pop();
   }
   while (!delay_link_.empty()) {
     delete *delay_link_.begin();
     delay_link_.erase(delay_link_.begin());
   }
@@ skipping 63 matching lines @@
   std::queue<NetworkPacket*> packets_to_deliver;
   {
     rtc::CritScope crit(&lock_);
     // Check the capacity link first.
     while (!capacity_link_.empty() &&
            time_now >= capacity_link_.front()->arrival_time()) {
       // Time to get this packet.
       NetworkPacket* packet = capacity_link_.front();
       capacity_link_.pop();
 
-      // Packets are randomly dropped after being affected by the bottleneck.
-      if (random_.Rand(100) < static_cast<uint32_t>(config_.loss_percent)) {
+      // Drop packets at an average rate of |config_.loss_percent| with
+      // and average loss burst length of |config_.avg_burst_loss_length|.
+      if (bursting_ || random_.Rand<double>() < prob_burst_loss_) {

[terelius, 2016/05/30 14:00:29]

It would easier to model the process if it was
if (bursting_) {
  // Drop the packet with some probability
}
else {
  // Drop the packet with some other probability
}
bursting = did_we_just_drop_a_packet

[philipel, 2016/05/30 14:42:42]

Done.

[stefan-webrtc, 2016/05/30 15:15:10]

Fyi, burst loss is typically modelled using a gilbert-elliot model. I think we
have an implementation already somewhere in the code

+        bursting_ = random_.Rand<double>() < prob_lose_next_;
         delete packet;
         continue;
       }
 
       int arrival_time_jitter = random_.Gaussian(
           config_.queue_delay_ms, config_.delay_standard_deviation_ms);
 
       // If reordering is not allowed then adjust arrival_time_jitter
       // to make sure all packets are sent in order.
       if (!config_.allow_reordering && !delay_link_.empty() &&
@@ skipping 34 matching lines @@
 int64_t FakeNetworkPipe::TimeUntilNextProcess() const {
   rtc::CritScope crit(&lock_);
   const int64_t kDefaultProcessIntervalMs = 30;
   if (capacity_link_.empty() || delay_link_.empty())
     return kDefaultProcessIntervalMs;
   return std::max<int64_t>(next_process_time_ - clock_->TimeInMilliseconds(),
                            0);
 }
 
 }  // namespace webrtc