src/net/quic/congestion_control/tcp_cubic_sender.h

   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 // TCP cubic send side congestion algorithm, emulates the behavior of
   6 // TCP cubic.
   7
   8 #ifndef NET_QUIC_CONGESTION_CONTROL_TCP_CUBIC_SENDER_H_
   9 #define NET_QUIC_CONGESTION_CONTROL_TCP_CUBIC_SENDER_H_
  10
  11 #include "base/basictypes.h"
  12 #include "base/compiler_specific.h"
  13 #include "net/base/net_export.h"
  14 #include "net/quic/congestion_control/cubic.h"
  15 #include "net/quic/congestion_control/hybrid_slow_start.h"
  16 #include "net/quic/congestion_control/send_algorithm_interface.h"
  17 #include "net/quic/quic_bandwidth.h"
  18 #include "net/quic/quic_protocol.h"
  19 #include "net/quic/quic_time.h"
  20
  21 namespace net {
  22
  23 // Default maximum packet size used in Linux TCP implementations.
  24 const QuicByteCount kDefaultTCPMSS = 1460;
  25
  26 namespace test {
  27 class TcpCubicSenderPeer;
  28 }  // namespace test
  29
  30 class NET_EXPORT_PRIVATE TcpCubicSender : public SendAlgorithmInterface {
  31  public:
  32   // Reno option and max_tcp_congestion_window are provided for testing.
  33   TcpCubicSender(const QuicClock* clock,
  34                  bool reno,
  35                  QuicTcpCongestionWindow max_tcp_congestion_window);
  36   virtual ~TcpCubicSender();
  37
  38   // Start implementation of SendAlgorithmInterface.
  39   virtual void SetFromConfig(const QuicConfig& config, bool is_server) OVERRIDE;
  40   virtual void SetMaxPacketSize(QuicByteCount max_packet_size) OVERRIDE;
  41   virtual void OnIncomingQuicCongestionFeedbackFrame(
  42       const QuicCongestionFeedbackFrame& feedback,
  43       QuicTime feedback_receive_time,
  44       const SentPacketsMap& sent_packets) OVERRIDE;
  45   virtual void OnPacketAcked(QuicPacketSequenceNumber acked_sequence_number,
  46                              QuicByteCount acked_bytes) OVERRIDE;
  47   virtual void OnPacketLost(QuicPacketSequenceNumber largest_loss,
  48                             QuicTime ack_receive_time) OVERRIDE;
  49   virtual bool OnPacketSent(QuicTime sent_time,
  50                             QuicPacketSequenceNumber sequence_number,
  51                             QuicByteCount bytes,
  52                             TransmissionType transmission_type,
  53                             HasRetransmittableData is_retransmittable) OVERRIDE;
  54   virtual void OnRetransmissionTimeout(bool packets_retransmitted) OVERRIDE;
  55   virtual void OnPacketAbandoned(QuicPacketSequenceNumber sequence_number,
  56                                  QuicByteCount abandoned_bytes) OVERRIDE;
  57   virtual QuicTime::Delta TimeUntilSend(
  58       QuicTime now,
  59       TransmissionType transmission_type,
  60       HasRetransmittableData has_retransmittable_data,
  61       IsHandshake handshake) OVERRIDE;
  62   virtual QuicBandwidth BandwidthEstimate() const OVERRIDE;
  63   virtual void UpdateRtt(QuicTime::Delta rtt_sample) OVERRIDE;
  64   virtual QuicTime::Delta SmoothedRtt() const OVERRIDE;
  65   virtual QuicTime::Delta RetransmissionDelay() const OVERRIDE;
  66   virtual QuicByteCount GetCongestionWindow() const OVERRIDE;
  67   // End implementation of SendAlgorithmInterface.
  68
  69  private:
  70   friend class test::TcpCubicSenderPeer;
  71
  72   QuicByteCount AvailableSendWindow();
  73   QuicByteCount SendWindow();
  74   void Reset();
  75   void MaybeIncreaseCwnd(QuicPacketSequenceNumber acked_sequence_number);
  76   bool IsCwndLimited() const;
  77   bool InRecovery() const;
  78   void OnTimeOut();
  79
  80   HybridSlowStart hybrid_slow_start_;
  81   Cubic cubic_;
  82
  83   // Reno provided for testing.
  84   const bool reno_;
  85
  86   // ACK counter for the Reno implementation.
  87   int64 congestion_window_count_;
  88
  89   // Receiver side advertised window.
  90   QuicByteCount receive_window_;
  91
  92   // Bytes in flight, aka bytes on the wire.
  93   QuicByteCount bytes_in_flight_;
  94
  95   // Bytes sent and acked since the last loss event.  Used for PRR.
  96   QuicByteCount prr_out_;
  97   QuicByteCount prr_delivered_;
  98   size_t ack_count_since_loss_;
  99
 100   // The congestion window before the last loss event.
 101   QuicByteCount bytes_in_flight_before_loss_;
 102
 103   // We need to keep track of the end sequence number of each RTT "burst".
 104   bool update_end_sequence_number_;
 105   QuicPacketSequenceNumber end_sequence_number_;
 106
 107   // Track the largest packet that has been sent.
 108   QuicPacketSequenceNumber largest_sent_sequence_number_;
 109
 110   // Track the largest packet that has been acked.
 111   QuicPacketSequenceNumber largest_acked_sequence_number_;
 112
 113   // Track the largest sequence number outstanding when a CWND cutback occurs.
 114   QuicPacketSequenceNumber largest_sent_at_last_cutback_;
 115
 116   // Congestion window in packets.
 117   QuicTcpCongestionWindow congestion_window_;
 118
 119   // Slow start congestion window in packets, aka ssthresh.
 120   QuicTcpCongestionWindow slowstart_threshold_;
 121
 122   // Maximum number of outstanding packets for tcp.
 123   QuicTcpCongestionWindow max_tcp_congestion_window_;
 124
 125   // Min RTT during this session.
 126   QuicTime::Delta delay_min_;
 127
 128   // Smoothed RTT during this session.
 129   QuicTime::Delta smoothed_rtt_;
 130
 131   // Mean RTT deviation during this session.
 132   // Approximation of standard deviation, the error is roughly 1.25 times
 133   // larger than the standard deviation, for a normally distributed signal.
 134   QuicTime::Delta mean_deviation_;
 135
 136   DISALLOW_COPY_AND_ASSIGN(TcpCubicSender);
 137 };
 138
 139 }  // namespace net
 140
 141 #endif  // NET_QUIC_CONGESTION_CONTROL_TCP_CUBIC_SENDER_H_