Home | History | Annotate | Download | only in congestion_control 
      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,
     47                              QuicTime::Delta rtt) OVERRIDE;
     48   virtual void OnPacketLost(QuicPacketSequenceNumber largest_loss,
     49                             QuicTime ack_receive_time) OVERRIDE;
     50   virtual bool OnPacketSent(QuicTime sent_time,
     51                             QuicPacketSequenceNumber sequence_number,
     52                             QuicByteCount bytes,
     53                             TransmissionType transmission_type,
     54                             HasRetransmittableData is_retransmittable) OVERRIDE;
     55   virtual void OnRetransmissionTimeout() OVERRIDE;
     56   virtual void OnPacketAbandoned(QuicPacketSequenceNumber sequence_number,
     57                                  QuicByteCount abandoned_bytes) OVERRIDE;
     58   virtual QuicTime::Delta TimeUntilSend(
     59       QuicTime now,
     60       TransmissionType transmission_type,
     61       HasRetransmittableData has_retransmittable_data,
     62       IsHandshake handshake) OVERRIDE;
     63   virtual QuicBandwidth BandwidthEstimate() const 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 AckAccounting(QuicTime::Delta rtt);
     76   void CongestionAvoidance(QuicPacketSequenceNumber ack);
     77   bool IsCwndLimited() 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   // Receiver side advertised packet loss.
     93   int last_received_accumulated_number_of_lost_packets_;
     94 
     95   // Bytes in flight, aka bytes on the wire.
     96   QuicByteCount bytes_in_flight_;
     97 
     98   // We need to keep track of the end sequence number of each RTT "burst".
     99   bool update_end_sequence_number_;
    100   QuicPacketSequenceNumber end_sequence_number_;
    101 
    102   // Track the largest packet that has been sent.
    103   QuicPacketSequenceNumber largest_sent_sequence_number_;
    104 
    105   // Track the largest packet that has been acked.
    106   QuicPacketSequenceNumber largest_acked_sequence_number_;
    107 
    108   // Track the largest sequence number outstanding when a CWND cutback occurs.
    109   QuicPacketSequenceNumber largest_sent_at_last_cutback_;
    110 
    111   // Congestion window in packets.
    112   QuicTcpCongestionWindow congestion_window_;
    113 
    114   // Slow start congestion window in packets.
    115   QuicTcpCongestionWindow slowstart_threshold_;
    116 
    117   // Maximum number of outstanding packets for tcp.
    118   QuicTcpCongestionWindow max_tcp_congestion_window_;
    119 
    120   // Min RTT during this session.
    121   QuicTime::Delta delay_min_;
    122 
    123   // Smoothed RTT during this session.
    124   QuicTime::Delta smoothed_rtt_;
    125 
    126   // Mean RTT deviation during this session.
    127   // Approximation of standard deviation, the error is roughly 1.25 times
    128   // larger than the standard deviation, for a normally distributed signal.
    129   QuicTime::Delta mean_deviation_;
    130 
    131   DISALLOW_COPY_AND_ASSIGN(TcpCubicSender);
    132 };
    133 
    134 }  // namespace net
    135 
    136 #endif  // NET_QUIC_CONGESTION_CONTROL_TCP_CUBIC_SENDER_H_
    137