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