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
21namespace net {
22
23// Default maximum packet size used in Linux TCP implementations.
24const QuicByteCount kDefaultTCPMSS = 1460;
25
26namespace test {
27class TcpCubicSenderPeer;
28}  // namespace test
29
30class 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