src/net/quic/congestion_control/available_channel_estimator.cc

   1 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "net/quic/congestion_control/available_channel_estimator.h"
   6
   7 static const int kNumberOfSamples = 9;
   8
   9 namespace net {
  10
  11 AvailableChannelEstimator::AvailableChannelEstimator(
  12     QuicPacketSequenceNumber sequence_number,
  13     QuicTime first_send_time,
  14     QuicTime first_receive_time)
  15     : first_sequence_number_(sequence_number),
  16       first_send_time_(first_send_time),
  17       first_receive_time_(first_receive_time),
  18       last_incorporated_sequence_number_(sequence_number),
  19       last_time_sent_(QuicTime::Zero()),
  20       last_receive_time_(QuicTime::Zero()),
  21       number_of_sequence_numbers_(0),
  22       received_bytes_(0) {
  23 }
  24
  25 void AvailableChannelEstimator::OnIncomingFeedback(
  26     QuicPacketSequenceNumber sequence_number,
  27     QuicByteCount packet_size,
  28     QuicTime sent_time,
  29     QuicTime receive_time) {
  30   if (sequence_number <= first_sequence_number_) {
  31     // Ignore pre-probe feedback.
  32     return;
  33   }
  34   if (sequence_number <= last_incorporated_sequence_number_) {
  35     // Ignore old feedback; will remove duplicates.
  36     return;
  37   }
  38   // Remember the highest received sequence number.
  39   last_incorporated_sequence_number_ = sequence_number;
  40   if (number_of_sequence_numbers_ < kNumberOfSamples) {
  41     // We don't care how many sequence numbers we have after we pass
  42     // kNumberOfSamples.
  43     number_of_sequence_numbers_++;
  44   }
  45   last_receive_time_ = receive_time;
  46   last_time_sent_ = sent_time;
  47   received_bytes_ += packet_size;
  48   // TODO(pwestin): the variance here should give us information about accuracy.
  49 }
  50
  51 AvailableChannelEstimateState
  52     AvailableChannelEstimator::GetAvailableChannelEstimate(
  53         QuicBandwidth* bandwidth) const {
  54   if (number_of_sequence_numbers_ < 2) {
  55     return kAvailableChannelEstimateUnknown;
  56   }
  57   QuicTime::Delta send_delta = last_time_sent_.Subtract(first_send_time_);
  58   QuicTime::Delta receive_delta =
  59       last_receive_time_.Subtract(first_receive_time_);
  60
  61   // TODO(pwestin): room for improvement here. Keeping it simple for now.
  62   *bandwidth = QuicBandwidth::FromBytesAndTimeDelta(received_bytes_,
  63                                                     receive_delta);
  64
  65   QuicTime::Delta diff = receive_delta.Subtract(send_delta);
  66   QuicTime::Delta ten_percent_of_send_time =
  67       QuicTime::Delta::FromMicroseconds(send_delta.ToMicroseconds() / 10);
  68
  69   if (diff < ten_percent_of_send_time) {
  70     return kAvailableChannelEstimateSenderLimited;
  71   }
  72   if (number_of_sequence_numbers_ < kNumberOfSamples) {
  73     return kAvailableChannelEstimateUncertain;
  74   }
  75   return kAvailableChannelEstimateGood;
  76 }
  77
  78 }  // namespace net