src/net/quic/congestion_control/fix_rate_sender.cc

   1 // Copyright (c) 2012 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/fix_rate_sender.h"
   6
   7 #include <math.h>
   8
   9 #include <algorithm>
  10
  11 #include "base/logging.h"
  12 #include "net/quic/quic_protocol.h"
  13
  14 namespace {
  15   const int kInitialBitrate = 100000;  // In bytes per second.
  16   const uint64 kWindowSizeUs = 10000;  // 10 ms.
  17 }
  18
  19 namespace net {
  20
  21 FixRateSender::FixRateSender(const QuicClock* clock)
  22     : bitrate_(QuicBandwidth::FromBytesPerSecond(kInitialBitrate)),
  23       max_segment_size_(kDefaultMaxPacketSize),
  24       fix_rate_leaky_bucket_(bitrate_),
  25       paced_sender_(bitrate_, max_segment_size_),
  26       data_in_flight_(0),
  27       latest_rtt_(QuicTime::Delta::Zero()) {
  28   DLOG(INFO) << "FixRateSender";
  29 }
  30
  31 FixRateSender::~FixRateSender() {
  32 }
  33
  34 void FixRateSender::SetFromConfig(const QuicConfig& config, bool is_server) {
  35   max_segment_size_ = config.server_max_packet_size();
  36   paced_sender_.set_max_segment_size(max_segment_size_);
  37 }
  38
  39 void FixRateSender::OnIncomingQuicCongestionFeedbackFrame(
  40     const QuicCongestionFeedbackFrame& feedback,
  41     QuicTime feedback_receive_time,
  42     const SentPacketsMap& /*sent_packets*/) {
  43   if (feedback.type != kFixRate) {
  44     LOG(DFATAL) << "Invalid incoming CongestionFeedbackType:" << feedback.type;
  45   }
  46   if (feedback.type == kFixRate) {
  47     bitrate_ = feedback.fix_rate.bitrate;
  48     fix_rate_leaky_bucket_.SetDrainingRate(feedback_receive_time, bitrate_);
  49     paced_sender_.UpdateBandwidthEstimate(feedback_receive_time, bitrate_);
  50   }
  51   // Silently ignore invalid messages in release mode.
  52 }
  53
  54 void FixRateSender::OnIncomingAck(
  55     QuicPacketSequenceNumber /*acked_sequence_number*/,
  56     QuicByteCount bytes_acked,
  57     QuicTime::Delta rtt) {
  58   // RTT can't be negative.
  59   DCHECK_LE(0, rtt.ToMicroseconds());
  60
  61   data_in_flight_ -= bytes_acked;
  62   if (rtt.IsInfinite()) {
  63     return;
  64   }
  65   latest_rtt_ = rtt;
  66 }
  67
  68 void FixRateSender::OnIncomingLoss(QuicTime /*ack_receive_time*/) {
  69   // Ignore losses for fix rate sender.
  70 }
  71
  72 bool FixRateSender::OnPacketSent(
  73     QuicTime sent_time,
  74     QuicPacketSequenceNumber /*sequence_number*/,
  75     QuicByteCount bytes,
  76     TransmissionType transmission_type,
  77     HasRetransmittableData /*has_retransmittable_data*/) {
  78   fix_rate_leaky_bucket_.Add(sent_time, bytes);
  79   paced_sender_.OnPacketSent(sent_time, bytes);
  80   if (transmission_type == NOT_RETRANSMISSION) {
  81     data_in_flight_ += bytes;
  82   }
  83   return true;
  84 }
  85
  86 void FixRateSender::OnPacketAbandoned(
  87     QuicPacketSequenceNumber /*sequence_number*/,
  88     QuicByteCount /*abandoned_bytes*/) {
  89 }
  90
  91 QuicTime::Delta FixRateSender::TimeUntilSend(
  92     QuicTime now,
  93     TransmissionType /* transmission_type */,
  94     HasRetransmittableData /*has_retransmittable_data*/,
  95     IsHandshake /*handshake*/) {
  96   if (CongestionWindow() > fix_rate_leaky_bucket_.BytesPending(now)) {
  97     if (CongestionWindow() <= data_in_flight_) {
  98       // We need an ack before we send more.
  99       return QuicTime::Delta::Infinite();
 100     }
 101     return paced_sender_.TimeUntilSend(now, QuicTime::Delta::Zero());
 102   }
 103   QuicTime::Delta time_remaining = fix_rate_leaky_bucket_.TimeRemaining(now);
 104   if (time_remaining.IsZero()) {
 105     // We need an ack before we send more.
 106     return QuicTime::Delta::Infinite();
 107   }
 108   return paced_sender_.TimeUntilSend(now, time_remaining);
 109 }
 110
 111 QuicByteCount FixRateSender::CongestionWindow() {
 112   QuicByteCount window_size_bytes = bitrate_.ToBytesPerPeriod(
 113       QuicTime::Delta::FromMicroseconds(kWindowSizeUs));
 114   // Make sure window size is not less than a packet.
 115   return std::max(kDefaultMaxPacketSize, window_size_bytes);
 116 }
 117
 118 QuicBandwidth FixRateSender::BandwidthEstimate() {
 119   return bitrate_;
 120 }
 121
 122 QuicTime::Delta FixRateSender::SmoothedRtt() {
 123   // TODO(satyamshekhar): Calculate and return smoothed rtt.
 124   return latest_rtt_;
 125 }
 126
 127 QuicTime::Delta FixRateSender::RetransmissionDelay() {
 128   // TODO(pwestin): Calculate and return retransmission delay.
 129   // Use 2 * the latest RTT for now.
 130   return latest_rtt_.Add(latest_rtt_);
 131 }
 132
 133 QuicByteCount FixRateSender::GetCongestionWindow() {
 134   return 0;
 135 }
 136
 137 void FixRateSender::SetCongestionWindow(QuicByteCount window) {
 138 }
 139
 140 }  // namespace net