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
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
|
// 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_BASE_H_
#define NET_QUIC_CONGESTION_CONTROL_TCP_CUBIC_SENDER_BASE_H_
#include <stdint.h>
#include "base/compiler_specific.h"
#include "base/macros.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/prr_sender.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 {
class RttStats;
// Maximum window to allow when doing bandwidth resumption.
const QuicPacketCount kMaxResumptionCongestionWindow = 200;
namespace test {
class TcpCubicSenderBasePeer;
} // namespace test
class NET_EXPORT_PRIVATE TcpCubicSenderBase : public SendAlgorithmInterface {
public:
// Reno option and max_tcp_congestion_window are provided for testing.
TcpCubicSenderBase(const QuicClock* clock,
const RttStats* rtt_stats,
bool reno,
QuicConnectionStats* stats);
~TcpCubicSenderBase() override;
// Start implementation of SendAlgorithmInterface.
void SetFromConfig(const QuicConfig& config,
Perspective perspective) override;
void ResumeConnectionState(
const CachedNetworkParameters& cached_network_params,
bool max_bandwidth_resumption) override;
void SetNumEmulatedConnections(int num_connections) override;
void OnCongestionEvent(bool rtt_updated,
QuicByteCount bytes_in_flight,
const CongestionVector& acked_packets,
const CongestionVector& lost_packets) override;
bool OnPacketSent(QuicTime sent_time,
QuicByteCount bytes_in_flight,
QuicPacketNumber packet_number,
QuicByteCount bytes,
HasRetransmittableData is_retransmittable) override;
void OnRetransmissionTimeout(bool packets_retransmitted) override;
void OnConnectionMigration() override;
QuicTime::Delta TimeUntilSend(QuicTime now,
QuicByteCount bytes_in_flight) const override;
QuicBandwidth PacingRate() const override;
QuicBandwidth BandwidthEstimate() const override;
QuicTime::Delta RetransmissionDelay() const override;
bool InSlowStart() const override;
bool InRecovery() const override;
protected:
// Called when resuming a previous bandwidth.
virtual void SetCongestionWindowFromBandwidthAndRtt(QuicBandwidth bandwidth,
QuicTime::Delta rtt) = 0;
// Called when initializing the congestion window.
virtual void SetCongestionWindowInPackets(
QuicPacketCount congestion_window) = 0;
// Called when initializing the minimum congestion window.
virtual void SetMinCongestionWindowInPackets(
QuicPacketCount congestion_window) = 0;
// Called when slow start is exited to set SSTHRESH.
virtual void ExitSlowstart() = 0;
// Called when a packet is lost.
virtual void OnPacketLost(QuicPacketNumber largest_loss,
QuicByteCount lost_bytes,
QuicByteCount bytes_in_flight) = 0;
// Called when a packet has been acked to possibly increase the congestion
// window.
virtual void MaybeIncreaseCwnd(QuicPacketNumber acked_packet_number,
QuicByteCount acked_bytes,
QuicByteCount bytes_in_flight) = 0;
// Called when a retransmission has occured which resulted in packets
// being retransmitted.
virtual void HandleRetransmissionTimeout() = 0;
// Compute the TCP Reno beta based on the current number of connections.
float RenoBeta() const;
bool IsCwndLimited(QuicByteCount bytes_in_flight) const;
private:
friend class test::TcpCubicSenderBasePeer;
// TODO(ianswett): Remove these and migrate to OnCongestionEvent.
void OnPacketAcked(QuicPacketNumber acked_packet_number,
QuicByteCount acked_bytes,
QuicByteCount bytes_in_flight);
protected:
// TODO(rch): Make these private and clean up subclass access to them.
HybridSlowStart hybrid_slow_start_;
PrrSender prr_;
const RttStats* rtt_stats_;
QuicConnectionStats* stats_;
// If true, Reno congestion control is used instead of Cubic.
const bool reno_;
// Number of connections to simulate.
uint32_t num_connections_;
// Track the largest packet that has been sent.
QuicPacketNumber largest_sent_packet_number_;
// Track the largest packet that has been acked.
QuicPacketNumber largest_acked_packet_number_;
// Track the largest packet number outstanding when a CWND cutback occurs.
QuicPacketNumber largest_sent_at_last_cutback_;
// Whether to use 4 packets as the actual min, but pace lower.
bool min4_mode_;
// Whether the last loss event caused us to exit slowstart.
// Used for stats collection of slowstart_packets_lost
bool last_cutback_exited_slowstart_;
// When true, exit slow start with large cutback of congestion window.
bool slow_start_large_reduction_;
private:
DISALLOW_COPY_AND_ASSIGN(TcpCubicSenderBase);
};
} // namespace net
#endif // NET_QUIC_CONGESTION_CONTROL_TCP_CUBIC_SENDER_BASE_H_
|
