Home | History | Annotate | Download | only in congestion_control 
      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
     79