summaryrefslogtreecommitdiffstats
path: root/net/quic/congestion_control
diff options
context:
space:
mode:
authorrtenneti <rtenneti@chromium.org>2015-08-27 23:44:57 -0700
committerCommit bot <commit-bot@chromium.org>2015-08-28 06:45:38 +0000
commita004d33c10dabb590f276e66ac52ccff43cb2d9f (patch)
treef8b7b272ea5f35ecd8382ab581c091f91ee588b4 /net/quic/congestion_control
parent0e3c57b2e9e14ec594015d425cf72cdd64f5df1b (diff)
downloadchromium_src-a004d33c10dabb590f276e66ac52ccff43cb2d9f.zip
chromium_src-a004d33c10dabb590f276e66ac52ccff43cb2d9f.tar.gz
chromium_src-a004d33c10dabb590f276e66ac52ccff43cb2d9f.tar.bz2
Landing Recent QUIC changes until 8/24/2015 18:33 UTC.
relnote: Rename "sequence number" to "packet number" in the QUIC code. Merge internal change: 101368603 https://codereview.chromium.org/1321603002/ relnote: Fixes a crash bug where when two packets were sent when write blocked, the second would sometimes succeed and then writes occurred out of order. Merge internal change: 101355922 https://codereview.chromium.org/1313373003/ relnote: Update QUIC's fec_alarm with a 1ms granularity to avoid setting it so often. Setting this alarm currently consumes over 1% of CPU on bandaid, even though FEC is disabled for most users. Merge internal change: 101213426 https://codereview.chromium.org/1322433004/ QUIC - small changes to keep the code similar to internal source. Internal release not: Add required header file and fully qualify std::max() and std::min(). These are currently implicitly included through base/scoped_ptr.h, which is going away. relnote: n/a (compilation fix in QUIC strike register) Merge internal change: 101113179 https://codereview.chromium.org/1315253002/ R=rch@chromium.org Review URL: https://codereview.chromium.org/1317113003 Cr-Commit-Position: refs/heads/master@{#346090}
Diffstat (limited to 'net/quic/congestion_control')
-rw-r--r--net/quic/congestion_control/hybrid_slow_start.cc27
-rw-r--r--net/quic/congestion_control/hybrid_slow_start.h17
-rw-r--r--net/quic/congestion_control/hybrid_slow_start_test.cc34
-rw-r--r--net/quic/congestion_control/loss_detection_interface.h4
-rw-r--r--net/quic/congestion_control/pacing_sender.cc6
-rw-r--r--net/quic/congestion_control/pacing_sender.h2
-rw-r--r--net/quic/congestion_control/pacing_sender_test.cc8
-rw-r--r--net/quic/congestion_control/prr_sender.cc3
-rw-r--r--net/quic/congestion_control/send_algorithm_interface.h4
-rw-r--r--net/quic/congestion_control/send_algorithm_simulator.cc27
-rw-r--r--net/quic/congestion_control/send_algorithm_simulator.h26
-rw-r--r--net/quic/congestion_control/tcp_cubic_bytes_sender.cc44
-rw-r--r--net/quic/congestion_control/tcp_cubic_bytes_sender.h16
-rw-r--r--net/quic/congestion_control/tcp_cubic_bytes_sender_test.cc36
-rw-r--r--net/quic/congestion_control/tcp_cubic_sender.cc47
-rw-r--r--net/quic/congestion_control/tcp_cubic_sender.h16
-rw-r--r--net/quic/congestion_control/tcp_cubic_sender_test.cc36
-rw-r--r--net/quic/congestion_control/tcp_loss_algorithm.cc20
-rw-r--r--net/quic/congestion_control/tcp_loss_algorithm.h9
-rw-r--r--net/quic/congestion_control/tcp_loss_algorithm_test.cc29
-rw-r--r--net/quic/congestion_control/time_loss_algorithm.cc16
-rw-r--r--net/quic/congestion_control/time_loss_algorithm.h9
-rw-r--r--net/quic/congestion_control/time_loss_algorithm_test.cc17
23 files changed, 223 insertions, 230 deletions
diff --git a/net/quic/congestion_control/hybrid_slow_start.cc b/net/quic/congestion_control/hybrid_slow_start.cc
index d6a47e4..7c0ba21 100644
--- a/net/quic/congestion_control/hybrid_slow_start.cc
+++ b/net/quic/congestion_control/hybrid_slow_start.cc
@@ -25,24 +25,23 @@ const int64 kHybridStartDelayMaxThresholdUs = 16000;
HybridSlowStart::HybridSlowStart()
: started_(false),
hystart_found_(NOT_FOUND),
- last_sent_sequence_number_(0),
- end_sequence_number_(0),
+ last_sent_packet_number_(0),
+ end_packet_number_(0),
rtt_sample_count_(0),
- current_min_rtt_(QuicTime::Delta::Zero()) {
-}
+ current_min_rtt_(QuicTime::Delta::Zero()) {}
-void HybridSlowStart::OnPacketAcked(
- QuicPacketSequenceNumber acked_sequence_number, bool in_slow_start) {
+void HybridSlowStart::OnPacketAcked(QuicPacketNumber acked_packet_number,
+ bool in_slow_start) {
// OnPacketAcked gets invoked after ShouldExitSlowStart, so it's best to end
// the round when the final packet of the burst is received and start it on
// the next incoming ack.
- if (in_slow_start && IsEndOfRound(acked_sequence_number)) {
+ if (in_slow_start && IsEndOfRound(acked_packet_number)) {
started_ = false;
}
}
-void HybridSlowStart::OnPacketSent(QuicPacketSequenceNumber sequence_number) {
- last_sent_sequence_number_ = sequence_number;
+void HybridSlowStart::OnPacketSent(QuicPacketNumber packet_number) {
+ last_sent_packet_number_ = packet_number;
}
void HybridSlowStart::Restart() {
@@ -50,16 +49,16 @@ void HybridSlowStart::Restart() {
hystart_found_ = NOT_FOUND;
}
-void HybridSlowStart::StartReceiveRound(QuicPacketSequenceNumber last_sent) {
+void HybridSlowStart::StartReceiveRound(QuicPacketNumber last_sent) {
DVLOG(1) << "Reset hybrid slow start @" << last_sent;
- end_sequence_number_ = last_sent;
+ end_packet_number_ = last_sent;
current_min_rtt_ = QuicTime::Delta::Zero();
rtt_sample_count_ = 0;
started_ = true;
}
-bool HybridSlowStart::IsEndOfRound(QuicPacketSequenceNumber ack) const {
- return end_sequence_number_ <= ack;
+bool HybridSlowStart::IsEndOfRound(QuicPacketNumber ack) const {
+ return end_packet_number_ <= ack;
}
bool HybridSlowStart::ShouldExitSlowStart(QuicTime::Delta latest_rtt,
@@ -67,7 +66,7 @@ bool HybridSlowStart::ShouldExitSlowStart(QuicTime::Delta latest_rtt,
QuicPacketCount congestion_window) {
if (!started_) {
// Time to start the hybrid slow start.
- StartReceiveRound(last_sent_sequence_number_);
+ StartReceiveRound(last_sent_packet_number_);
}
if (hystart_found_ != NOT_FOUND) {
return true;
diff --git a/net/quic/congestion_control/hybrid_slow_start.h b/net/quic/congestion_control/hybrid_slow_start.h
index 9f0a9ae..457ef3e 100644
--- a/net/quic/congestion_control/hybrid_slow_start.h
+++ b/net/quic/congestion_control/hybrid_slow_start.h
@@ -27,10 +27,9 @@ class NET_EXPORT_PRIVATE HybridSlowStart {
public:
HybridSlowStart();
- void OnPacketAcked(QuicPacketSequenceNumber acked_sequence_number,
- bool in_slow_start);
+ void OnPacketAcked(QuicPacketNumber acked_packet_number, bool in_slow_start);
- void OnPacketSent(QuicPacketSequenceNumber sequence_number);
+ void OnPacketSent(QuicPacketNumber packet_number);
// ShouldExitSlowStart should be called on every new ack frame, since a new
// RTT measurement can be made then.
@@ -46,13 +45,13 @@ class NET_EXPORT_PRIVATE HybridSlowStart {
// TODO(ianswett): The following methods should be private, but that requires
// a follow up CL to update the unit test.
- // Returns true if this ack the last sequence number of our current slow start
+ // Returns true if this ack the last packet number of our current slow start
// round.
// Call Reset if this returns true.
- bool IsEndOfRound(QuicPacketSequenceNumber ack) const;
+ bool IsEndOfRound(QuicPacketNumber ack) const;
// Call for the start of each receive round (burst) in the slow start phase.
- void StartReceiveRound(QuicPacketSequenceNumber last_sent);
+ void StartReceiveRound(QuicPacketNumber last_sent);
// Whether slow start has started.
bool started() const {
@@ -69,11 +68,11 @@ class NET_EXPORT_PRIVATE HybridSlowStart {
// Whether the hybrid slow start has been started.
bool started_;
HystartState hystart_found_;
- // Last sequence number sent which was CWND limited.
- QuicPacketSequenceNumber last_sent_sequence_number_;
+ // Last packet number sent which was CWND limited.
+ QuicPacketNumber last_sent_packet_number_;
// Variables for tracking acks received during a slow start round.
- QuicPacketSequenceNumber end_sequence_number_; // End of the receive round.
+ QuicPacketNumber end_packet_number_; // End of the receive round.
uint32 rtt_sample_count_; // Number of rtt samples in the current round.
QuicTime::Delta current_min_rtt_; // The minimum rtt of current round.
diff --git a/net/quic/congestion_control/hybrid_slow_start_test.cc b/net/quic/congestion_control/hybrid_slow_start_test.cc
index 97dc32f..b923904 100644
--- a/net/quic/congestion_control/hybrid_slow_start_test.cc
+++ b/net/quic/congestion_control/hybrid_slow_start_test.cc
@@ -23,27 +23,27 @@ class HybridSlowStartTest : public ::testing::Test {
};
TEST_F(HybridSlowStartTest, Simple) {
- QuicPacketSequenceNumber sequence_number = 1;
- QuicPacketSequenceNumber end_sequence_number = 3;
- slow_start_->StartReceiveRound(end_sequence_number);
+ QuicPacketNumber packet_number = 1;
+ QuicPacketNumber end_packet_number = 3;
+ slow_start_->StartReceiveRound(end_packet_number);
- EXPECT_FALSE(slow_start_->IsEndOfRound(sequence_number++));
+ EXPECT_FALSE(slow_start_->IsEndOfRound(packet_number++));
// Test duplicates.
- EXPECT_FALSE(slow_start_->IsEndOfRound(sequence_number));
+ EXPECT_FALSE(slow_start_->IsEndOfRound(packet_number));
- EXPECT_FALSE(slow_start_->IsEndOfRound(sequence_number++));
- EXPECT_TRUE(slow_start_->IsEndOfRound(sequence_number++));
+ EXPECT_FALSE(slow_start_->IsEndOfRound(packet_number++));
+ EXPECT_TRUE(slow_start_->IsEndOfRound(packet_number++));
- // Test without a new registered end_sequence_number;
- EXPECT_TRUE(slow_start_->IsEndOfRound(sequence_number++));
+ // Test without a new registered end_packet_number;
+ EXPECT_TRUE(slow_start_->IsEndOfRound(packet_number++));
- end_sequence_number = 20;
- slow_start_->StartReceiveRound(end_sequence_number);
- while (sequence_number < end_sequence_number) {
- EXPECT_FALSE(slow_start_->IsEndOfRound(sequence_number++));
+ end_packet_number = 20;
+ slow_start_->StartReceiveRound(end_packet_number);
+ while (packet_number < end_packet_number) {
+ EXPECT_FALSE(slow_start_->IsEndOfRound(packet_number++));
}
- EXPECT_TRUE(slow_start_->IsEndOfRound(sequence_number++));
+ EXPECT_TRUE(slow_start_->IsEndOfRound(packet_number++));
}
TEST_F(HybridSlowStartTest, Delay) {
@@ -51,8 +51,8 @@ TEST_F(HybridSlowStartTest, Delay) {
// RTT of 60ms the detection will happen at 67.5 ms.
const int kHybridStartMinSamples = 8; // Number of acks required to trigger.
- QuicPacketSequenceNumber end_sequence_number = 1;
- slow_start_->StartReceiveRound(end_sequence_number++);
+ QuicPacketNumber end_packet_number = 1;
+ slow_start_->StartReceiveRound(end_packet_number++);
// Will not trigger since our lowest RTT in our burst is the same as the long
// term RTT provided.
@@ -60,7 +60,7 @@ TEST_F(HybridSlowStartTest, Delay) {
EXPECT_FALSE(slow_start_->ShouldExitSlowStart(
rtt_.Add(QuicTime::Delta::FromMilliseconds(n)), rtt_, 100));
}
- slow_start_->StartReceiveRound(end_sequence_number++);
+ slow_start_->StartReceiveRound(end_packet_number++);
for (int n = 1; n < kHybridStartMinSamples; ++n) {
EXPECT_FALSE(slow_start_->ShouldExitSlowStart(
rtt_.Add(QuicTime::Delta::FromMilliseconds(n + 10)), rtt_, 100));
diff --git a/net/quic/congestion_control/loss_detection_interface.h b/net/quic/congestion_control/loss_detection_interface.h
index 5aaa51d..d10f24a 100644
--- a/net/quic/congestion_control/loss_detection_interface.h
+++ b/net/quic/congestion_control/loss_detection_interface.h
@@ -26,10 +26,10 @@ class NET_EXPORT_PRIVATE LossDetectionInterface {
virtual LossDetectionType GetLossDetectionType() const = 0;
// Called when a new ack arrives or the loss alarm fires.
- virtual SequenceNumberSet DetectLostPackets(
+ virtual PacketNumberSet DetectLostPackets(
const QuicUnackedPacketMap& unacked_packets,
const QuicTime& time,
- QuicPacketSequenceNumber largest_observed,
+ QuicPacketNumber largest_observed,
const RttStats& rtt_stats) = 0;
// Get the time the LossDetectionAlgorithm wants to re-evaluate losses.
diff --git a/net/quic/congestion_control/pacing_sender.cc b/net/quic/congestion_control/pacing_sender.cc
index a8bd13f..21dd4f3 100644
--- a/net/quic/congestion_control/pacing_sender.cc
+++ b/net/quic/congestion_control/pacing_sender.cc
@@ -53,12 +53,12 @@ void PacingSender::OnCongestionEvent(bool rtt_updated,
bool PacingSender::OnPacketSent(
QuicTime sent_time,
QuicByteCount bytes_in_flight,
- QuicPacketSequenceNumber sequence_number,
+ QuicPacketNumber packet_number,
QuicByteCount bytes,
HasRetransmittableData has_retransmittable_data) {
const bool in_flight =
- sender_->OnPacketSent(sent_time, bytes_in_flight, sequence_number,
- bytes, has_retransmittable_data);
+ sender_->OnPacketSent(sent_time, bytes_in_flight, packet_number, bytes,
+ has_retransmittable_data);
if (has_retransmittable_data != HAS_RETRANSMITTABLE_DATA) {
return in_flight;
}
diff --git a/net/quic/congestion_control/pacing_sender.h b/net/quic/congestion_control/pacing_sender.h
index 8d9dbda..f9c3f7b 100644
--- a/net/quic/congestion_control/pacing_sender.h
+++ b/net/quic/congestion_control/pacing_sender.h
@@ -48,7 +48,7 @@ class NET_EXPORT_PRIVATE PacingSender : public SendAlgorithmInterface {
const CongestionVector& lost_packets) override;
bool OnPacketSent(QuicTime sent_time,
QuicByteCount bytes_in_flight,
- QuicPacketSequenceNumber sequence_number,
+ QuicPacketNumber packet_number,
QuicByteCount bytes,
HasRetransmittableData is_retransmittable) override;
void OnRetransmissionTimeout(bool packets_retransmitted) override;
diff --git a/net/quic/congestion_control/pacing_sender_test.cc b/net/quic/congestion_control/pacing_sender_test.cc
index b7e3755..25ca2a7 100644
--- a/net/quic/congestion_control/pacing_sender_test.cc
+++ b/net/quic/congestion_control/pacing_sender_test.cc
@@ -26,7 +26,7 @@ class PacingSenderTest : public ::testing::Test {
PacingSenderTest()
: zero_time_(QuicTime::Delta::Zero()),
infinite_time_(QuicTime::Delta::Infinite()),
- sequence_number_(1),
+ packet_number_(1),
mock_sender_(new StrictMock<MockSendAlgorithm>()),
pacing_sender_(new PacingSender(mock_sender_,
QuicTime::Delta::FromMilliseconds(1),
@@ -61,10 +61,10 @@ class PacingSenderTest : public ::testing::Test {
// Actually send the packet.
EXPECT_CALL(*mock_sender_,
- OnPacketSent(clock_.Now(), bytes_in_flight, sequence_number_,
+ OnPacketSent(clock_.Now(), bytes_in_flight, packet_number_,
kMaxPacketSize, retransmittable_data));
pacing_sender_->OnPacketSent(clock_.Now(), bytes_in_flight,
- sequence_number_++, kMaxPacketSize,
+ packet_number_++, kMaxPacketSize,
retransmittable_data);
}
@@ -102,7 +102,7 @@ class PacingSenderTest : public ::testing::Test {
const QuicTime::Delta zero_time_;
const QuicTime::Delta infinite_time_;
MockClock clock_;
- QuicPacketSequenceNumber sequence_number_;
+ QuicPacketNumber packet_number_;
StrictMock<MockSendAlgorithm>* mock_sender_;
scoped_ptr<PacingSender> pacing_sender_;
};
diff --git a/net/quic/congestion_control/prr_sender.cc b/net/quic/congestion_control/prr_sender.cc
index 51b32d3..e84bae8 100644
--- a/net/quic/congestion_control/prr_sender.cc
+++ b/net/quic/congestion_control/prr_sender.cc
@@ -40,6 +40,9 @@ QuicTime::Delta PrrSender::TimeUntilSend(
QuicByteCount congestion_window,
QuicByteCount bytes_in_flight,
QuicByteCount slowstart_threshold) const {
+ // if (FLAGS_?? && bytes_in_flight < congestion_window) {
+ // return QuicTime::Delta::Zero();
+ // }
// Return QuicTime::Zero In order to ensure limited transmit always works.
if (bytes_sent_since_loss_ == 0 || bytes_in_flight < kMaxSegmentSize) {
return QuicTime::Delta::Zero();
diff --git a/net/quic/congestion_control/send_algorithm_interface.h b/net/quic/congestion_control/send_algorithm_interface.h
index d1caac9..3daee55 100644
--- a/net/quic/congestion_control/send_algorithm_interface.h
+++ b/net/quic/congestion_control/send_algorithm_interface.h
@@ -27,7 +27,7 @@ class RttStats;
class NET_EXPORT_PRIVATE SendAlgorithmInterface {
public:
// A sorted vector of packets.
- typedef std::vector<std::pair<QuicPacketSequenceNumber, TransmissionInfo>>
+ typedef std::vector<std::pair<QuicPacketNumber, TransmissionInfo>>
CongestionVector;
static SendAlgorithmInterface* Create(
@@ -67,7 +67,7 @@ class NET_EXPORT_PRIVATE SendAlgorithmInterface {
// Note: this function must be called for every packet sent to the wire.
virtual bool OnPacketSent(QuicTime sent_time,
QuicByteCount bytes_in_flight,
- QuicPacketSequenceNumber sequence_number,
+ QuicPacketNumber packet_number,
QuicByteCount bytes,
HasRetransmittableData is_retransmittable) = 0;
diff --git a/net/quic/congestion_control/send_algorithm_simulator.cc b/net/quic/congestion_control/send_algorithm_simulator.cc
index 64f0ee1..ff58090 100644
--- a/net/quic/congestion_control/send_algorithm_simulator.cc
+++ b/net/quic/congestion_control/send_algorithm_simulator.cc
@@ -116,7 +116,7 @@ void SendAlgorithmSimulator::TransferBytes(QuicByteCount max_bytes,
DVLOG(1) << "Handling ack of largest observed:"
<< ack_event.transfer->sender->next_acked << ", advancing time:"
<< ack_event.time_delta.ToMicroseconds() << "us";
- // Ack data all the data up to ack time and lose any missing sequence
+ // Ack data all the data up to ack time and lose any missing packet
// numbers.
clock_->AdvanceTime(ack_event.time_delta);
HandlePendingAck(ack_event.transfer);
@@ -190,7 +190,7 @@ QuicTime::Delta SendAlgorithmSimulator::FindNextAcked(Transfer* transfer) {
reverse_loss_rate_ * kuint64max > simple_random_.RandUint64();
}
- QuicPacketSequenceNumber next_acked = sender->last_acked;
+ QuicPacketNumber next_acked = sender->last_acked;
QuicTime::Delta next_ack_delay =
FindNextAck(transfer, sender->last_acked, &next_acked);
if (lose_next_ack_) {
@@ -202,8 +202,8 @@ QuicTime::Delta SendAlgorithmSimulator::FindNextAcked(Transfer* transfer) {
QuicTime::Delta SendAlgorithmSimulator::FindNextAck(
const Transfer* transfer,
- QuicPacketSequenceNumber last_acked,
- QuicPacketSequenceNumber* next_acked) const {
+ QuicPacketNumber last_acked,
+ QuicPacketNumber* next_acked) const {
*next_acked = last_acked;
QuicTime::Delta ack_delay = QuicTime::Delta::Infinite();
// Remove any packets that are simulated as lost.
@@ -213,19 +213,19 @@ QuicTime::Delta SendAlgorithmSimulator::FindNextAck(
continue;
}
// Skip over any packets less than or equal to last_acked.
- if (it->sequence_number <= last_acked) {
+ if (it->packet_number <= last_acked) {
continue;
}
// Lost packets don't trigger an ack.
if (it->lost) {
continue;
}
- DCHECK_LT(*next_acked, it->sequence_number);
+ DCHECK_LT(*next_acked, it->packet_number);
// Consider a delayed ack for the current next_acked.
if (ack_delay < it->ack_time.Subtract(clock_->Now())) {
break;
}
- *next_acked = it->sequence_number;
+ *next_acked = it->packet_number;
ack_delay = it->ack_time.Subtract(clock_->Now());
if (HasRecentLostPackets(transfer, *next_acked) ||
(*next_acked - last_acked) >= 2) {
@@ -241,10 +241,11 @@ QuicTime::Delta SendAlgorithmSimulator::FindNextAck(
}
bool SendAlgorithmSimulator::HasRecentLostPackets(
- const Transfer* transfer, QuicPacketSequenceNumber next_acked) const {
- QuicPacketSequenceNumber last_packet = transfer->sender->last_acked;
+ const Transfer* transfer,
+ QuicPacketNumber next_acked) const {
+ QuicPacketNumber last_packet = transfer->sender->last_acked;
for (list<SentPacket>::const_iterator it = sent_packets_.begin();
- it != sent_packets_.end() && it->sequence_number < next_acked; ++it) {
+ it != sent_packets_.end() && it->packet_number < next_acked; ++it) {
if (transfer != it->transfer) {
continue;
}
@@ -254,10 +255,10 @@ bool SendAlgorithmSimulator::HasRecentLostPackets(
}
// Buffer dropped packets are skipped automatically, but still end up
// being lost and cause acks to be sent immediately.
- if (it->sequence_number > last_packet + 1) {
+ if (it->packet_number > last_packet + 1) {
return true;
}
- last_packet = it->sequence_number;
+ last_packet = it->packet_number;
}
return false;
}
@@ -286,7 +287,7 @@ void SendAlgorithmSimulator::HandlePendingAck(Transfer* transfer) {
++it;
}
// If it's missing from the array, it's a loss.
- if (it->sequence_number > sender->last_acked) {
+ if (it->packet_number > sender->last_acked) {
DVLOG(1) << "Lost packet:" << sender->last_acked
<< " dropped by buffer overflow.";
lost_packets.push_back(std::make_pair(sender->last_acked, info));
diff --git a/net/quic/congestion_control/send_algorithm_simulator.h b/net/quic/congestion_control/send_algorithm_simulator.h
index 50e78f3..4f96bb8 100644
--- a/net/quic/congestion_control/send_algorithm_simulator.h
+++ b/net/quic/congestion_control/send_algorithm_simulator.h
@@ -59,12 +59,12 @@ class SendAlgorithmSimulator {
RttStats* rtt_stats;
QuicTime::Delta additional_rtt;
- // Last sequence number the sender sent.
- QuicPacketSequenceNumber last_sent;
- // Last packet sequence number acked.
- QuicPacketSequenceNumber last_acked;
- // Packet sequence number to ack up to.
- QuicPacketSequenceNumber next_acked;
+ // Last packet number the sender sent.
+ QuicPacketNumber last_sent;
+ // Last packet number acked.
+ QuicPacketNumber last_acked;
+ // packet number to ack up to.
+ QuicPacketNumber next_acked;
// Stats collected for understanding the congestion control.
QuicByteCount max_cwnd;
@@ -93,23 +93,23 @@ class SendAlgorithmSimulator {
struct SentPacket {
SentPacket()
- : sequence_number(0),
+ : packet_number(0),
send_time(QuicTime::Zero()),
ack_time(QuicTime::Zero()),
lost(false),
transfer(nullptr) {}
- SentPacket(QuicPacketSequenceNumber sequence_number,
+ SentPacket(QuicPacketNumber packet_number,
QuicTime send_time,
QuicTime ack_time,
bool lost,
Transfer* transfer)
- : sequence_number(sequence_number),
+ : packet_number(packet_number),
send_time(send_time),
ack_time(ack_time),
lost(lost),
transfer(transfer) {}
- QuicPacketSequenceNumber sequence_number;
+ QuicPacketNumber packet_number;
QuicTime send_time;
QuicTime ack_time;
bool lost;
@@ -200,13 +200,13 @@ class SendAlgorithmSimulator {
// |last_acked|. Returns QuicTime::Delta::Infinite and doesn't set
// |next_acked| if there is no ack after |last_acked|.
QuicTime::Delta FindNextAck(const Transfer* transfer,
- QuicPacketSequenceNumber last_acked,
- QuicPacketSequenceNumber* next_acked) const;
+ QuicPacketNumber last_acked,
+ QuicPacketNumber* next_acked) const;
// Returns true if any of the packets |transfer| is waiting for less than
// next_acked have been lost.
bool HasRecentLostPackets(const Transfer* transfer,
- QuicPacketSequenceNumber next_acked) const;
+ QuicPacketNumber next_acked) const;
// Process all the acks that should have arrived by the current time, and
// lose any packets that are missing. Returns the number of bytes acked.
diff --git a/net/quic/congestion_control/tcp_cubic_bytes_sender.cc b/net/quic/congestion_control/tcp_cubic_bytes_sender.cc
index f3d4711..9f15e9f 100644
--- a/net/quic/congestion_control/tcp_cubic_bytes_sender.cc
+++ b/net/quic/congestion_control/tcp_cubic_bytes_sender.cc
@@ -40,8 +40,8 @@ TcpCubicBytesSender::TcpCubicBytesSender(
reno_(reno),
num_connections_(kDefaultNumConnections),
num_acked_packets_(0),
- largest_sent_sequence_number_(0),
- largest_acked_sequence_number_(0),
+ largest_sent_packet_number_(0),
+ largest_acked_packet_number_(0),
largest_sent_at_last_cutback_(0),
congestion_window_(initial_tcp_congestion_window * kMaxSegmentSize),
min_congestion_window_(kDefaultMinimumCongestionWindow),
@@ -49,8 +49,7 @@ TcpCubicBytesSender::TcpCubicBytesSender(
max_congestion_window_(max_congestion_window * kMaxSegmentSize),
slowstart_threshold_(max_congestion_window * kMaxSegmentSize),
last_cutback_exited_slowstart_(false),
- clock_(clock) {
-}
+ clock_(clock) {}
TcpCubicBytesSender::~TcpCubicBytesSender() {
}
@@ -133,31 +132,30 @@ void TcpCubicBytesSender::OnCongestionEvent(
}
}
-void TcpCubicBytesSender::OnPacketAcked(
- QuicPacketSequenceNumber acked_sequence_number,
- QuicByteCount acked_bytes,
- QuicByteCount bytes_in_flight) {
- largest_acked_sequence_number_ =
- max(acked_sequence_number, largest_acked_sequence_number_);
+void TcpCubicBytesSender::OnPacketAcked(QuicPacketNumber acked_packet_number,
+ QuicByteCount acked_bytes,
+ QuicByteCount bytes_in_flight) {
+ largest_acked_packet_number_ =
+ max(acked_packet_number, largest_acked_packet_number_);
if (InRecovery()) {
// PRR is used when in recovery.
prr_.OnPacketAcked(acked_bytes);
return;
}
- MaybeIncreaseCwnd(acked_sequence_number, acked_bytes, bytes_in_flight);
+ MaybeIncreaseCwnd(acked_packet_number, acked_bytes, bytes_in_flight);
// TODO(ianswett): Should this even be called when not in slow start?
- hybrid_slow_start_.OnPacketAcked(acked_sequence_number, InSlowStart());
+ hybrid_slow_start_.OnPacketAcked(acked_packet_number, InSlowStart());
}
-void TcpCubicBytesSender::OnPacketLost(QuicPacketSequenceNumber sequence_number,
+void TcpCubicBytesSender::OnPacketLost(QuicPacketNumber packet_number,
QuicByteCount bytes_in_flight) {
// TCP NewReno (RFC6582) says that once a loss occurs, any losses in packets
// already sent should be treated as a single loss event, since it's expected.
- if (sequence_number <= largest_sent_at_last_cutback_) {
+ if (packet_number <= largest_sent_at_last_cutback_) {
if (last_cutback_exited_slowstart_) {
++stats_->slowstart_packets_lost;
}
- DVLOG(1) << "Ignoring loss for largest_missing:" << sequence_number
+ DVLOG(1) << "Ignoring loss for largest_missing:" << packet_number
<< " because it was sent prior to the last CWND cutback.";
return;
}
@@ -180,7 +178,7 @@ void TcpCubicBytesSender::OnPacketLost(QuicPacketSequenceNumber sequence_number,
if (congestion_window_ < min_congestion_window_) {
congestion_window_ = min_congestion_window_;
}
- largest_sent_at_last_cutback_ = largest_sent_sequence_number_;
+ largest_sent_at_last_cutback_ = largest_sent_packet_number_;
// Reset packet count from congestion avoidance mode. We start counting again
// when we're out of recovery.
num_acked_packets_ = 0;
@@ -191,7 +189,7 @@ void TcpCubicBytesSender::OnPacketLost(QuicPacketSequenceNumber sequence_number,
bool TcpCubicBytesSender::OnPacketSent(
QuicTime /*sent_time*/,
QuicByteCount /*bytes_in_flight*/,
- QuicPacketSequenceNumber sequence_number,
+ QuicPacketNumber packet_number,
QuicByteCount bytes,
HasRetransmittableData is_retransmittable) {
if (InSlowStart()) {
@@ -206,9 +204,9 @@ bool TcpCubicBytesSender::OnPacketSent(
// PRR is used when in recovery.
prr_.OnPacketSent(bytes);
}
- DCHECK_LT(largest_sent_sequence_number_, sequence_number);
- largest_sent_sequence_number_ = sequence_number;
- hybrid_slow_start_.OnPacketSent(sequence_number);
+ DCHECK_LT(largest_sent_packet_number_, packet_number);
+ largest_sent_packet_number_ = packet_number;
+ hybrid_slow_start_.OnPacketSent(packet_number);
return true;
}
@@ -287,14 +285,14 @@ bool TcpCubicBytesSender::IsCwndLimited(QuicByteCount bytes_in_flight) const {
}
bool TcpCubicBytesSender::InRecovery() const {
- return largest_acked_sequence_number_ <= largest_sent_at_last_cutback_ &&
- largest_acked_sequence_number_ != 0;
+ return largest_acked_packet_number_ <= largest_sent_at_last_cutback_ &&
+ largest_acked_packet_number_ != 0;
}
// Called when we receive an ack. Normal TCP tracks how many packets one ack
// represents, but quic has a separate ack for each packet.
void TcpCubicBytesSender::MaybeIncreaseCwnd(
- QuicPacketSequenceNumber acked_sequence_number,
+ QuicPacketNumber acked_packet_number,
QuicByteCount acked_bytes,
QuicByteCount bytes_in_flight) {
LOG_IF(DFATAL, InRecovery()) << "Never increase the CWND during recovery.";
diff --git a/net/quic/congestion_control/tcp_cubic_bytes_sender.h b/net/quic/congestion_control/tcp_cubic_bytes_sender.h
index 663bc11..7a345f6 100644
--- a/net/quic/congestion_control/tcp_cubic_bytes_sender.h
+++ b/net/quic/congestion_control/tcp_cubic_bytes_sender.h
@@ -50,7 +50,7 @@ class NET_EXPORT_PRIVATE TcpCubicBytesSender : public SendAlgorithmInterface {
const CongestionVector& lost_packets) override;
bool OnPacketSent(QuicTime sent_time,
QuicByteCount bytes_in_flight,
- QuicPacketSequenceNumber sequence_number,
+ QuicPacketNumber packet_number,
QuicByteCount bytes,
HasRetransmittableData is_retransmittable) override;
void OnRetransmissionTimeout(bool packets_retransmitted) override;
@@ -75,13 +75,13 @@ class NET_EXPORT_PRIVATE TcpCubicBytesSender : public SendAlgorithmInterface {
float RenoBeta() const;
// TODO(ianswett): Remove these and migrate to OnCongestionEvent.
- void OnPacketAcked(QuicPacketSequenceNumber acked_sequence_number,
+ void OnPacketAcked(QuicPacketNumber acked_packet_number,
QuicByteCount acked_bytes,
QuicByteCount bytes_in_flight);
- void OnPacketLost(QuicPacketSequenceNumber largest_loss,
+ void OnPacketLost(QuicPacketNumber largest_loss,
QuicByteCount bytes_in_flight);
- void MaybeIncreaseCwnd(QuicPacketSequenceNumber acked_sequence_number,
+ void MaybeIncreaseCwnd(QuicPacketNumber acked_packet_number,
QuicByteCount acked_bytes,
QuicByteCount bytes_in_flight);
bool IsCwndLimited(QuicByteCount bytes_in_flight) const;
@@ -102,13 +102,13 @@ class NET_EXPORT_PRIVATE TcpCubicBytesSender : public SendAlgorithmInterface {
uint64 num_acked_packets_;
// Track the largest packet that has been sent.
- QuicPacketSequenceNumber largest_sent_sequence_number_;
+ QuicPacketNumber largest_sent_packet_number_;
// Track the largest packet that has been acked.
- QuicPacketSequenceNumber largest_acked_sequence_number_;
+ QuicPacketNumber largest_acked_packet_number_;
- // Track the largest sequence number outstanding when a CWND cutback occurs.
- QuicPacketSequenceNumber largest_sent_at_last_cutback_;
+ // Track the largest packet number outstanding when a CWND cutback occurs.
+ QuicPacketNumber largest_sent_at_last_cutback_;
// Congestion window in bytes.
QuicByteCount congestion_window_;
diff --git a/net/quic/congestion_control/tcp_cubic_bytes_sender_test.cc b/net/quic/congestion_control/tcp_cubic_bytes_sender_test.cc
index e58a29c..dbc9a73 100644
--- a/net/quic/congestion_control/tcp_cubic_bytes_sender_test.cc
+++ b/net/quic/congestion_control/tcp_cubic_bytes_sender_test.cc
@@ -53,8 +53,8 @@ class TcpCubicBytesSenderTest : public ::testing::Test {
TcpCubicBytesSenderTest()
: one_ms_(QuicTime::Delta::FromMilliseconds(1)),
sender_(new TcpCubicBytesSenderPeer(&clock_, true)),
- sequence_number_(1),
- acked_sequence_number_(0),
+ packet_number_(1),
+ acked_packet_number_(0),
bytes_in_flight_(0) {
standard_packet_.bytes_sent = kDefaultTCPMSS;
}
@@ -65,7 +65,7 @@ class TcpCubicBytesSenderTest : public ::testing::Test {
bool can_send = sender_->TimeUntilSend(clock_.Now(), bytes_in_flight_,
HAS_RETRANSMITTABLE_DATA).IsZero();
while (can_send) {
- sender_->OnPacketSent(clock_.Now(), bytes_in_flight_, sequence_number_++,
+ sender_->OnPacketSent(clock_.Now(), bytes_in_flight_, packet_number_++,
kDefaultTCPMSS, HAS_RETRANSMITTABLE_DATA);
++packets_sent;
bytes_in_flight_ += kDefaultTCPMSS;
@@ -82,9 +82,9 @@ class TcpCubicBytesSenderTest : public ::testing::Test {
SendAlgorithmInterface::CongestionVector acked_packets;
SendAlgorithmInterface::CongestionVector lost_packets;
for (int i = 0; i < n; ++i) {
- ++acked_sequence_number_;
+ ++acked_packet_number_;
acked_packets.push_back(
- std::make_pair(acked_sequence_number_, standard_packet_));
+ std::make_pair(acked_packet_number_, standard_packet_));
}
sender_->OnCongestionEvent(true, bytes_in_flight_, acked_packets,
lost_packets);
@@ -96,20 +96,20 @@ class TcpCubicBytesSenderTest : public ::testing::Test {
SendAlgorithmInterface::CongestionVector acked_packets;
SendAlgorithmInterface::CongestionVector lost_packets;
for (int i = 0; i < n; ++i) {
- ++acked_sequence_number_;
+ ++acked_packet_number_;
lost_packets.push_back(
- std::make_pair(acked_sequence_number_, standard_packet_));
+ std::make_pair(acked_packet_number_, standard_packet_));
}
sender_->OnCongestionEvent(false, bytes_in_flight_, acked_packets,
lost_packets);
bytes_in_flight_ -= n * kDefaultTCPMSS;
}
- // Does not increment acked_sequence_number_.
- void LosePacket(QuicPacketSequenceNumber sequence_number) {
+ // Does not increment acked_packet_number_.
+ void LosePacket(QuicPacketNumber packet_number) {
SendAlgorithmInterface::CongestionVector acked_packets;
SendAlgorithmInterface::CongestionVector lost_packets;
- lost_packets.push_back(std::make_pair(sequence_number, standard_packet_));
+ lost_packets.push_back(std::make_pair(packet_number, standard_packet_));
sender_->OnCongestionEvent(false, bytes_in_flight_, acked_packets,
lost_packets);
bytes_in_flight_ -= kDefaultTCPMSS;
@@ -118,8 +118,8 @@ class TcpCubicBytesSenderTest : public ::testing::Test {
const QuicTime::Delta one_ms_;
MockClock clock_;
scoped_ptr<TcpCubicBytesSenderPeer> sender_;
- QuicPacketSequenceNumber sequence_number_;
- QuicPacketSequenceNumber acked_sequence_number_;
+ QuicPacketNumber packet_number_;
+ QuicPacketNumber acked_packet_number_;
QuicByteCount bytes_in_flight_;
TransmissionInfo standard_packet_;
};
@@ -405,28 +405,28 @@ TEST_F(TcpCubicBytesSenderTest, RetransmissionDelay) {
TEST_F(TcpCubicBytesSenderTest, MultipleLossesInOneWindow) {
SendAvailableSendWindow();
const QuicByteCount initial_window = sender_->GetCongestionWindow();
- LosePacket(acked_sequence_number_ + 1);
+ LosePacket(acked_packet_number_ + 1);
const QuicByteCount post_loss_window = sender_->GetCongestionWindow();
EXPECT_GT(initial_window, post_loss_window);
- LosePacket(acked_sequence_number_ + 3);
+ LosePacket(acked_packet_number_ + 3);
EXPECT_EQ(post_loss_window, sender_->GetCongestionWindow());
- LosePacket(sequence_number_ - 1);
+ LosePacket(packet_number_ - 1);
EXPECT_EQ(post_loss_window, sender_->GetCongestionWindow());
// Lose a later packet and ensure the window decreases.
- LosePacket(sequence_number_);
+ LosePacket(packet_number_);
EXPECT_GT(post_loss_window, sender_->GetCongestionWindow());
}
TEST_F(TcpCubicBytesSenderTest, DontTrackAckPackets) {
// Send a packet with no retransmittable data, and ensure it's not tracked.
EXPECT_FALSE(sender_->OnPacketSent(clock_.Now(), bytes_in_flight_,
- sequence_number_++, kDefaultTCPMSS,
+ packet_number_++, kDefaultTCPMSS,
NO_RETRANSMITTABLE_DATA));
// Send a data packet with retransmittable data, and ensure it is tracked.
EXPECT_TRUE(sender_->OnPacketSent(clock_.Now(), bytes_in_flight_,
- sequence_number_++, kDefaultTCPMSS,
+ packet_number_++, kDefaultTCPMSS,
HAS_RETRANSMITTABLE_DATA));
}
diff --git a/net/quic/congestion_control/tcp_cubic_sender.cc b/net/quic/congestion_control/tcp_cubic_sender.cc
index 5e1fb25..e39b243 100644
--- a/net/quic/congestion_control/tcp_cubic_sender.cc
+++ b/net/quic/congestion_control/tcp_cubic_sender.cc
@@ -40,8 +40,8 @@ TcpCubicSender::TcpCubicSender(const QuicClock* clock,
reno_(reno),
num_connections_(kDefaultNumConnections),
congestion_window_count_(0),
- largest_sent_sequence_number_(0),
- largest_acked_sequence_number_(0),
+ largest_sent_packet_number_(0),
+ largest_acked_packet_number_(0),
largest_sent_at_last_cutback_(0),
congestion_window_(initial_tcp_congestion_window),
min_congestion_window_(kDefaultMinimumCongestionWindow),
@@ -49,8 +49,7 @@ TcpCubicSender::TcpCubicSender(const QuicClock* clock,
slowstart_threshold_(max_tcp_congestion_window),
last_cutback_exited_slowstart_(false),
max_tcp_congestion_window_(max_tcp_congestion_window),
- clock_(clock) {
-}
+ clock_(clock) {}
TcpCubicSender::~TcpCubicSender() {
UMA_HISTOGRAM_COUNTS("Net.QuicSession.FinalTcpCwnd", congestion_window_);
@@ -149,31 +148,30 @@ void TcpCubicSender::OnCongestionEvent(
}
}
-void TcpCubicSender::OnPacketAcked(
- QuicPacketSequenceNumber acked_sequence_number,
- QuicByteCount acked_bytes,
- QuicByteCount bytes_in_flight) {
- largest_acked_sequence_number_ = max(acked_sequence_number,
- largest_acked_sequence_number_);
+void TcpCubicSender::OnPacketAcked(QuicPacketNumber acked_packet_number,
+ QuicByteCount acked_bytes,
+ QuicByteCount bytes_in_flight) {
+ largest_acked_packet_number_ =
+ max(acked_packet_number, largest_acked_packet_number_);
if (InRecovery()) {
// PRR is used when in recovery.
prr_.OnPacketAcked(acked_bytes);
return;
}
- MaybeIncreaseCwnd(acked_sequence_number, bytes_in_flight);
+ MaybeIncreaseCwnd(acked_packet_number, bytes_in_flight);
// TODO(ianswett): Should this even be called when not in slow start?
- hybrid_slow_start_.OnPacketAcked(acked_sequence_number, InSlowStart());
+ hybrid_slow_start_.OnPacketAcked(acked_packet_number, InSlowStart());
}
-void TcpCubicSender::OnPacketLost(QuicPacketSequenceNumber sequence_number,
+void TcpCubicSender::OnPacketLost(QuicPacketNumber packet_number,
QuicByteCount bytes_in_flight) {
// TCP NewReno (RFC6582) says that once a loss occurs, any losses in packets
// already sent should be treated as a single loss event, since it's expected.
- if (sequence_number <= largest_sent_at_last_cutback_) {
+ if (packet_number <= largest_sent_at_last_cutback_) {
if (last_cutback_exited_slowstart_) {
++stats_->slowstart_packets_lost;
}
- DVLOG(1) << "Ignoring loss for largest_missing:" << sequence_number
+ DVLOG(1) << "Ignoring loss for largest_missing:" << packet_number
<< " because it was sent prior to the last CWND cutback.";
return;
}
@@ -196,7 +194,7 @@ void TcpCubicSender::OnPacketLost(QuicPacketSequenceNumber sequence_number,
if (congestion_window_ < min_congestion_window_) {
congestion_window_ = min_congestion_window_;
}
- largest_sent_at_last_cutback_ = largest_sent_sequence_number_;
+ largest_sent_at_last_cutback_ = largest_sent_packet_number_;
// reset packet count from congestion avoidance mode. We start
// counting again when we're out of recovery.
congestion_window_count_ = 0;
@@ -206,7 +204,7 @@ void TcpCubicSender::OnPacketLost(QuicPacketSequenceNumber sequence_number,
bool TcpCubicSender::OnPacketSent(QuicTime /*sent_time*/,
QuicByteCount /*bytes_in_flight*/,
- QuicPacketSequenceNumber sequence_number,
+ QuicPacketNumber packet_number,
QuicByteCount bytes,
HasRetransmittableData is_retransmittable) {
if (InSlowStart()) {
@@ -221,9 +219,9 @@ bool TcpCubicSender::OnPacketSent(QuicTime /*sent_time*/,
// PRR is used when in recovery.
prr_.OnPacketSent(bytes);
}
- DCHECK_LT(largest_sent_sequence_number_, sequence_number);
- largest_sent_sequence_number_ = sequence_number;
- hybrid_slow_start_.OnPacketSent(sequence_number);
+ DCHECK_LT(largest_sent_packet_number_, packet_number);
+ largest_sent_packet_number_ = packet_number;
+ hybrid_slow_start_.OnPacketSent(packet_number);
return true;
}
@@ -304,15 +302,14 @@ bool TcpCubicSender::IsCwndLimited(QuicByteCount bytes_in_flight) const {
}
bool TcpCubicSender::InRecovery() const {
- return largest_acked_sequence_number_ <= largest_sent_at_last_cutback_ &&
- largest_acked_sequence_number_ != 0;
+ return largest_acked_packet_number_ <= largest_sent_at_last_cutback_ &&
+ largest_acked_packet_number_ != 0;
}
// Called when we receive an ack. Normal TCP tracks how many packets one ack
// represents, but quic has a separate ack for each packet.
-void TcpCubicSender::MaybeIncreaseCwnd(
- QuicPacketSequenceNumber acked_sequence_number,
- QuicByteCount bytes_in_flight) {
+void TcpCubicSender::MaybeIncreaseCwnd(QuicPacketNumber acked_packet_number,
+ QuicByteCount bytes_in_flight) {
LOG_IF(DFATAL, InRecovery()) << "Never increase the CWND during recovery.";
if (!IsCwndLimited(bytes_in_flight)) {
// We don't update the congestion window unless we are close to using the
diff --git a/net/quic/congestion_control/tcp_cubic_sender.h b/net/quic/congestion_control/tcp_cubic_sender.h
index 394a12e..1e82401 100644
--- a/net/quic/congestion_control/tcp_cubic_sender.h
+++ b/net/quic/congestion_control/tcp_cubic_sender.h
@@ -52,7 +52,7 @@ class NET_EXPORT_PRIVATE TcpCubicSender : public SendAlgorithmInterface {
const CongestionVector& lost_packets) override;
bool OnPacketSent(QuicTime sent_time,
QuicByteCount bytes_in_flight,
- QuicPacketSequenceNumber sequence_number,
+ QuicPacketNumber packet_number,
QuicByteCount bytes,
HasRetransmittableData is_retransmittable) override;
void OnRetransmissionTimeout(bool packets_retransmitted) override;
@@ -77,13 +77,13 @@ class NET_EXPORT_PRIVATE TcpCubicSender : public SendAlgorithmInterface {
float RenoBeta() const;
// TODO(ianswett): Remove these and migrate to OnCongestionEvent.
- void OnPacketAcked(QuicPacketSequenceNumber acked_sequence_number,
+ void OnPacketAcked(QuicPacketNumber acked_packet_number,
QuicByteCount acked_bytes,
QuicByteCount bytes_in_flight);
- void OnPacketLost(QuicPacketSequenceNumber largest_loss,
+ void OnPacketLost(QuicPacketNumber largest_loss,
QuicByteCount bytes_in_flight);
- void MaybeIncreaseCwnd(QuicPacketSequenceNumber acked_sequence_number,
+ void MaybeIncreaseCwnd(QuicPacketNumber acked_packet_number,
QuicByteCount bytes_in_flight);
bool IsCwndLimited(QuicByteCount bytes_in_flight) const;
@@ -103,13 +103,13 @@ class NET_EXPORT_PRIVATE TcpCubicSender : public SendAlgorithmInterface {
uint64 congestion_window_count_;
// Track the largest packet that has been sent.
- QuicPacketSequenceNumber largest_sent_sequence_number_;
+ QuicPacketNumber largest_sent_packet_number_;
// Track the largest packet that has been acked.
- QuicPacketSequenceNumber largest_acked_sequence_number_;
+ QuicPacketNumber largest_acked_packet_number_;
- // Track the largest sequence number outstanding when a CWND cutback occurs.
- QuicPacketSequenceNumber largest_sent_at_last_cutback_;
+ // Track the largest packet number outstanding when a CWND cutback occurs.
+ QuicPacketNumber largest_sent_at_last_cutback_;
// Congestion window in packets.
QuicPacketCount congestion_window_;
diff --git a/net/quic/congestion_control/tcp_cubic_sender_test.cc b/net/quic/congestion_control/tcp_cubic_sender_test.cc
index 90773b3..9376e4e 100644
--- a/net/quic/congestion_control/tcp_cubic_sender_test.cc
+++ b/net/quic/congestion_control/tcp_cubic_sender_test.cc
@@ -66,8 +66,8 @@ class TcpCubicSenderTest : public ::testing::Test {
TcpCubicSenderTest()
: one_ms_(QuicTime::Delta::FromMilliseconds(1)),
sender_(new TcpCubicSenderPeer(&clock_, true, kMaxCongestionWindow)),
- sequence_number_(1),
- acked_sequence_number_(0),
+ packet_number_(1),
+ acked_packet_number_(0),
bytes_in_flight_(0) {
standard_packet_.bytes_sent = kDefaultTCPMSS;
}
@@ -78,7 +78,7 @@ class TcpCubicSenderTest : public ::testing::Test {
bool can_send = sender_->TimeUntilSend(
clock_.Now(), bytes_in_flight_, HAS_RETRANSMITTABLE_DATA).IsZero();
while (can_send) {
- sender_->OnPacketSent(clock_.Now(), bytes_in_flight_, sequence_number_++,
+ sender_->OnPacketSent(clock_.Now(), bytes_in_flight_, packet_number_++,
kDefaultTCPMSS, HAS_RETRANSMITTABLE_DATA);
++packets_sent;
bytes_in_flight_ += kDefaultTCPMSS;
@@ -96,9 +96,9 @@ class TcpCubicSenderTest : public ::testing::Test {
SendAlgorithmInterface::CongestionVector acked_packets;
SendAlgorithmInterface::CongestionVector lost_packets;
for (int i = 0; i < n; ++i) {
- ++acked_sequence_number_;
+ ++acked_packet_number_;
acked_packets.push_back(
- std::make_pair(acked_sequence_number_, standard_packet_));
+ std::make_pair(acked_packet_number_, standard_packet_));
}
sender_->OnCongestionEvent(
true, bytes_in_flight_, acked_packets, lost_packets);
@@ -110,20 +110,20 @@ class TcpCubicSenderTest : public ::testing::Test {
SendAlgorithmInterface::CongestionVector acked_packets;
SendAlgorithmInterface::CongestionVector lost_packets;
for (int i = 0; i < n; ++i) {
- ++acked_sequence_number_;
+ ++acked_packet_number_;
lost_packets.push_back(
- std::make_pair(acked_sequence_number_, standard_packet_));
+ std::make_pair(acked_packet_number_, standard_packet_));
}
sender_->OnCongestionEvent(
false, bytes_in_flight_, acked_packets, lost_packets);
bytes_in_flight_ -= n * kDefaultTCPMSS;
}
- // Does not increment acked_sequence_number_.
- void LosePacket(QuicPacketSequenceNumber sequence_number) {
+ // Does not increment acked_packet_number_.
+ void LosePacket(QuicPacketNumber packet_number) {
SendAlgorithmInterface::CongestionVector acked_packets;
SendAlgorithmInterface::CongestionVector lost_packets;
- lost_packets.push_back(std::make_pair(sequence_number, standard_packet_));
+ lost_packets.push_back(std::make_pair(packet_number, standard_packet_));
sender_->OnCongestionEvent(
false, bytes_in_flight_, acked_packets, lost_packets);
bytes_in_flight_ -= kDefaultTCPMSS;
@@ -132,8 +132,8 @@ class TcpCubicSenderTest : public ::testing::Test {
const QuicTime::Delta one_ms_;
MockClock clock_;
scoped_ptr<TcpCubicSenderPeer> sender_;
- QuicPacketSequenceNumber sequence_number_;
- QuicPacketSequenceNumber acked_sequence_number_;
+ QuicPacketNumber packet_number_;
+ QuicPacketNumber acked_packet_number_;
QuicByteCount bytes_in_flight_;
TransmissionInfo standard_packet_;
};
@@ -487,28 +487,28 @@ TEST_F(TcpCubicSenderTest, TcpCubicMaxCongestionWindow) {
TEST_F(TcpCubicSenderTest, MultipleLossesInOneWindow) {
SendAvailableSendWindow();
const QuicByteCount initial_window = sender_->GetCongestionWindow();
- LosePacket(acked_sequence_number_ + 1);
+ LosePacket(acked_packet_number_ + 1);
const QuicByteCount post_loss_window = sender_->GetCongestionWindow();
EXPECT_GT(initial_window, post_loss_window);
- LosePacket(acked_sequence_number_ + 3);
+ LosePacket(acked_packet_number_ + 3);
EXPECT_EQ(post_loss_window, sender_->GetCongestionWindow());
- LosePacket(sequence_number_ - 1);
+ LosePacket(packet_number_ - 1);
EXPECT_EQ(post_loss_window, sender_->GetCongestionWindow());
// Lose a later packet and ensure the window decreases.
- LosePacket(sequence_number_);
+ LosePacket(packet_number_);
EXPECT_GT(post_loss_window, sender_->GetCongestionWindow());
}
TEST_F(TcpCubicSenderTest, DontTrackAckPackets) {
// Send a packet with no retransmittable data, and ensure it's not tracked.
EXPECT_FALSE(sender_->OnPacketSent(clock_.Now(), bytes_in_flight_,
- sequence_number_++, kDefaultTCPMSS,
+ packet_number_++, kDefaultTCPMSS,
NO_RETRANSMITTABLE_DATA));
// Send a data packet with retransmittable data, and ensure it is tracked.
EXPECT_TRUE(sender_->OnPacketSent(clock_.Now(), bytes_in_flight_,
- sequence_number_++, kDefaultTCPMSS,
+ packet_number_++, kDefaultTCPMSS,
HAS_RETRANSMITTABLE_DATA));
}
diff --git a/net/quic/congestion_control/tcp_loss_algorithm.cc b/net/quic/congestion_control/tcp_loss_algorithm.cc
index f657cc2..2302d9f 100644
--- a/net/quic/congestion_control/tcp_loss_algorithm.cc
+++ b/net/quic/congestion_control/tcp_loss_algorithm.cc
@@ -30,31 +30,31 @@ LossDetectionType TCPLossAlgorithm::GetLossDetectionType() const {
}
// Uses nack counts to decide when packets are lost.
-SequenceNumberSet TCPLossAlgorithm::DetectLostPackets(
+PacketNumberSet TCPLossAlgorithm::DetectLostPackets(
const QuicUnackedPacketMap& unacked_packets,
const QuicTime& time,
- QuicPacketSequenceNumber largest_observed,
+ QuicPacketNumber largest_observed,
const RttStats& rtt_stats) {
- SequenceNumberSet lost_packets;
+ PacketNumberSet lost_packets;
loss_detection_timeout_ = QuicTime::Zero();
QuicTime::Delta early_retransmit_delay = QuicTime::Delta::Max(
QuicTime::Delta::FromMilliseconds(kMinLossDelayMs),
rtt_stats.smoothed_rtt().Multiply(kEarlyRetransmitLossDelayMultiplier));
- QuicPacketSequenceNumber sequence_number = unacked_packets.GetLeastUnacked();
+ QuicPacketNumber packet_number = unacked_packets.GetLeastUnacked();
for (QuicUnackedPacketMap::const_iterator it = unacked_packets.begin();
- it != unacked_packets.end() && sequence_number <= largest_observed;
- ++it, ++sequence_number) {
+ it != unacked_packets.end() && packet_number <= largest_observed;
+ ++it, ++packet_number) {
if (!it->in_flight) {
continue;
}
LOG_IF(DFATAL, it->nack_count == 0 && it->sent_time.IsInitialized())
<< "All packets less than largest observed should have been nacked."
- << "sequence_number:" << sequence_number
+ << "packet_number:" << packet_number
<< " largest_observed:" << largest_observed;
if (it->nack_count >= kNumberOfNacksBeforeRetransmission) {
- lost_packets.insert(sequence_number);
+ lost_packets.insert(packet_number);
continue;
}
@@ -64,7 +64,7 @@ SequenceNumberSet TCPLossAlgorithm::DetectLostPackets(
// kNumberOfNacksBeforeRetransmission nacks.
if (it->sent_time.Add(rtt_stats.smoothed_rtt()) <
unacked_packets.GetTransmissionInfo(largest_observed).sent_time) {
- lost_packets.insert(sequence_number);
+ lost_packets.insert(packet_number);
continue;
}
@@ -76,7 +76,7 @@ SequenceNumberSet TCPLossAlgorithm::DetectLostPackets(
// Early retransmit marks the packet as lost once 1.25RTTs have passed
// since the packet was sent and otherwise sets an alarm.
if (time >= it->sent_time.Add(early_retransmit_delay)) {
- lost_packets.insert(sequence_number);
+ lost_packets.insert(packet_number);
} else {
// Set the timeout for the earliest retransmittable packet where early
// retransmit applies.
diff --git a/net/quic/congestion_control/tcp_loss_algorithm.h b/net/quic/congestion_control/tcp_loss_algorithm.h
index a5f245e..9894c6b 100644
--- a/net/quic/congestion_control/tcp_loss_algorithm.h
+++ b/net/quic/congestion_control/tcp_loss_algorithm.h
@@ -29,11 +29,10 @@ class NET_EXPORT_PRIVATE TCPLossAlgorithm : public LossDetectionInterface {
LossDetectionType GetLossDetectionType() const override;
// Uses nack counts to decide when packets are lost.
- SequenceNumberSet DetectLostPackets(
- const QuicUnackedPacketMap& unacked_packets,
- const QuicTime& time,
- QuicPacketSequenceNumber largest_observed,
- const RttStats& rtt_stats) override;
+ PacketNumberSet DetectLostPackets(const QuicUnackedPacketMap& unacked_packets,
+ const QuicTime& time,
+ QuicPacketNumber largest_observed,
+ const RttStats& rtt_stats) override;
// Returns a non-zero value when the early retransmit timer is active.
QuicTime GetLossTimeout() const override;
diff --git a/net/quic/congestion_control/tcp_loss_algorithm_test.cc b/net/quic/congestion_control/tcp_loss_algorithm_test.cc
index 35b68e8..80474f4 100644
--- a/net/quic/congestion_control/tcp_loss_algorithm_test.cc
+++ b/net/quic/congestion_control/tcp_loss_algorithm_test.cc
@@ -35,21 +35,20 @@ class TcpLossAlgorithmTest : public ::testing::Test {
STLDeleteElements(&packets_);
}
- void SendDataPacket(QuicPacketSequenceNumber sequence_number) {
+ void SendDataPacket(QuicPacketNumber packet_number) {
packets_.push_back(new QuicEncryptedPacket(nullptr, kDefaultLength));
SerializedPacket packet(
- sequence_number, PACKET_1BYTE_SEQUENCE_NUMBER, packets_.back(), 0,
+ packet_number, PACKET_1BYTE_PACKET_NUMBER, packets_.back(), 0,
new RetransmittableFrames(ENCRYPTION_NONE), false, false);
unacked_packets_.AddSentPacket(packet, 0, NOT_RETRANSMISSION, clock_.Now(),
1000, true);
}
- void VerifyLosses(QuicPacketSequenceNumber largest_observed,
- QuicPacketSequenceNumber* losses_expected,
+ void VerifyLosses(QuicPacketNumber largest_observed,
+ QuicPacketNumber* losses_expected,
size_t num_losses) {
- SequenceNumberSet lost_packets =
- loss_algorithm_.DetectLostPackets(
- unacked_packets_, clock_.Now(), largest_observed, rtt_stats_);
+ PacketNumberSet lost_packets = loss_algorithm_.DetectLostPackets(
+ unacked_packets_, clock_.Now(), largest_observed, rtt_stats_);
EXPECT_EQ(num_losses, lost_packets.size());
for (size_t i = 0; i < num_losses; ++i) {
EXPECT_TRUE(ContainsKey(lost_packets, losses_expected[i]));
@@ -81,7 +80,7 @@ TEST_F(TcpLossAlgorithmTest, NackRetransmit1Packet) {
// Loss on three acks.
unacked_packets_.RemoveFromInFlight(4);
unacked_packets_.NackPacket(1, 3);
- QuicPacketSequenceNumber lost[] = {1};
+ QuicPacketNumber lost[] = {1};
VerifyLosses(4, lost, arraysize(lost));
EXPECT_EQ(QuicTime::Zero(), loss_algorithm_.GetLossTimeout());
}
@@ -100,7 +99,7 @@ TEST_F(TcpLossAlgorithmTest, NackRetransmit1PacketWith1StretchAck) {
unacked_packets_.RemoveFromInFlight(2);
unacked_packets_.RemoveFromInFlight(3);
unacked_packets_.RemoveFromInFlight(4);
- QuicPacketSequenceNumber lost[] = { 1 };
+ QuicPacketNumber lost[] = {1};
VerifyLosses(4, lost, arraysize(lost));
EXPECT_EQ(QuicTime::Zero(), loss_algorithm_.GetLossTimeout());
}
@@ -118,7 +117,7 @@ TEST_F(TcpLossAlgorithmTest, NackRetransmit1PacketSingleAck) {
unacked_packets_.NackPacket(2, 2);
unacked_packets_.NackPacket(3, 1);
unacked_packets_.RemoveFromInFlight(4);
- QuicPacketSequenceNumber lost[] = { 1 };
+ QuicPacketNumber lost[] = {1};
VerifyLosses(4, lost, arraysize(lost));
EXPECT_EQ(QuicTime::Zero(), loss_algorithm_.GetLossTimeout());
}
@@ -137,7 +136,7 @@ TEST_F(TcpLossAlgorithmTest, EarlyRetransmit1Packet) {
loss_algorithm_.GetLossTimeout());
clock_.AdvanceTime(rtt_stats_.latest_rtt().Multiply(1.25));
- QuicPacketSequenceNumber lost[] = { 1 };
+ QuicPacketNumber lost[] = {1};
VerifyLosses(2, lost, arraysize(lost));
EXPECT_EQ(QuicTime::Zero(), loss_algorithm_.GetLossTimeout());
}
@@ -159,7 +158,7 @@ TEST_F(TcpLossAlgorithmTest, EarlyRetransmitAllPackets) {
for (size_t i = 1; i < kNumSentPackets; ++i) {
unacked_packets_.NackPacket(i, kNumSentPackets - i);
}
- QuicPacketSequenceNumber lost[] = { 1, 2 };
+ QuicPacketNumber lost[] = {1, 2};
VerifyLosses(kNumSentPackets, lost, arraysize(lost));
// The time has already advanced 1/4 an RTT, so ensure the timeout is set
// 1.25 RTTs after the earliest pending packet(3), not the last(4).
@@ -167,12 +166,12 @@ TEST_F(TcpLossAlgorithmTest, EarlyRetransmitAllPackets) {
loss_algorithm_.GetLossTimeout());
clock_.AdvanceTime(rtt_stats_.smoothed_rtt());
- QuicPacketSequenceNumber lost2[] = { 1, 2, 3 };
+ QuicPacketNumber lost2[] = {1, 2, 3};
VerifyLosses(kNumSentPackets, lost2, arraysize(lost2));
EXPECT_EQ(clock_.Now().Add(rtt_stats_.smoothed_rtt().Multiply(0.25)),
loss_algorithm_.GetLossTimeout());
clock_.AdvanceTime(rtt_stats_.smoothed_rtt().Multiply(0.25));
- QuicPacketSequenceNumber lost3[] = { 1, 2, 3, 4 };
+ QuicPacketNumber lost3[] = {1, 2, 3, 4};
VerifyLosses(kNumSentPackets, lost3, arraysize(lost3));
EXPECT_EQ(QuicTime::Zero(), loss_algorithm_.GetLossTimeout());
}
@@ -209,7 +208,7 @@ TEST_F(TcpLossAlgorithmTest, AlwaysLosePacketSent1RTTEarlier) {
unacked_packets_.IncreaseLargestObserved(2);
unacked_packets_.RemoveFromInFlight(2);
unacked_packets_.NackPacket(1, 1);
- QuicPacketSequenceNumber lost[] = {1};
+ QuicPacketNumber lost[] = {1};
VerifyLosses(2, lost, arraysize(lost));
}
diff --git a/net/quic/congestion_control/time_loss_algorithm.cc b/net/quic/congestion_control/time_loss_algorithm.cc
index b5f90b7..3d500dc 100644
--- a/net/quic/congestion_control/time_loss_algorithm.cc
+++ b/net/quic/congestion_control/time_loss_algorithm.cc
@@ -27,28 +27,28 @@ LossDetectionType TimeLossAlgorithm::GetLossDetectionType() const {
return kTime;
}
-SequenceNumberSet TimeLossAlgorithm::DetectLostPackets(
+PacketNumberSet TimeLossAlgorithm::DetectLostPackets(
const QuicUnackedPacketMap& unacked_packets,
const QuicTime& time,
- QuicPacketSequenceNumber largest_observed,
+ QuicPacketNumber largest_observed,
const RttStats& rtt_stats) {
- SequenceNumberSet lost_packets;
+ PacketNumberSet lost_packets;
loss_detection_timeout_ = QuicTime::Zero();
QuicTime::Delta loss_delay = QuicTime::Delta::Max(
QuicTime::Delta::FromMilliseconds(kMinLossDelayMs),
QuicTime::Delta::Max(rtt_stats.smoothed_rtt(), rtt_stats.latest_rtt())
.Multiply(kLossDelayMultiplier));
- QuicPacketSequenceNumber sequence_number = unacked_packets.GetLeastUnacked();
+ QuicPacketNumber packet_number = unacked_packets.GetLeastUnacked();
for (QuicUnackedPacketMap::const_iterator it = unacked_packets.begin();
- it != unacked_packets.end() && sequence_number <= largest_observed;
- ++it, ++sequence_number) {
+ it != unacked_packets.end() && packet_number <= largest_observed;
+ ++it, ++packet_number) {
if (!it->in_flight) {
continue;
}
LOG_IF(DFATAL, it->nack_count == 0 && it->sent_time.IsInitialized())
<< "All packets less than largest observed should have been nacked."
- << "sequence_number:" << sequence_number
+ << "packet_number:" << packet_number
<< " largest_observed:" << largest_observed;
// Packets are sent in order, so break when we haven't waited long enough
@@ -58,7 +58,7 @@ SequenceNumberSet TimeLossAlgorithm::DetectLostPackets(
loss_detection_timeout_ = when_lost;
break;
}
- lost_packets.insert(sequence_number);
+ lost_packets.insert(packet_number);
}
return lost_packets;
diff --git a/net/quic/congestion_control/time_loss_algorithm.h b/net/quic/congestion_control/time_loss_algorithm.h
index 794a07d..bf1224e 100644
--- a/net/quic/congestion_control/time_loss_algorithm.h
+++ b/net/quic/congestion_control/time_loss_algorithm.h
@@ -28,11 +28,10 @@ class NET_EXPORT_PRIVATE TimeLossAlgorithm : public LossDetectionInterface {
// Declares pending packets less than the largest observed lost when it has
// been 1.25 RTT since they were sent. Packets larger than the largest
// observed are retransmitted via TLP.
- SequenceNumberSet DetectLostPackets(
- const QuicUnackedPacketMap& unacked_packets,
- const QuicTime& time,
- QuicPacketSequenceNumber largest_observed,
- const RttStats& rtt_stats) override;
+ PacketNumberSet DetectLostPackets(const QuicUnackedPacketMap& unacked_packets,
+ const QuicTime& time,
+ QuicPacketNumber largest_observed,
+ const RttStats& rtt_stats) override;
// Returns the time the next packet will be lost, or zero if there
// are no nacked pending packets outstanding.
diff --git a/net/quic/congestion_control/time_loss_algorithm_test.cc b/net/quic/congestion_control/time_loss_algorithm_test.cc
index e95e715..fb3d752 100644
--- a/net/quic/congestion_control/time_loss_algorithm_test.cc
+++ b/net/quic/congestion_control/time_loss_algorithm_test.cc
@@ -35,21 +35,20 @@ class TimeLossAlgorithmTest : public ::testing::Test {
STLDeleteElements(&packets_);
}
- void SendDataPacket(QuicPacketSequenceNumber sequence_number) {
+ void SendDataPacket(QuicPacketNumber packet_number) {
packets_.push_back(new QuicEncryptedPacket(nullptr, kDefaultLength));
SerializedPacket packet(
- sequence_number, PACKET_1BYTE_SEQUENCE_NUMBER, packets_.back(), 0,
+ packet_number, PACKET_1BYTE_PACKET_NUMBER, packets_.back(), 0,
new RetransmittableFrames(ENCRYPTION_NONE), false, false);
unacked_packets_.AddSentPacket(packet, 0, NOT_RETRANSMISSION, clock_.Now(),
1000, true);
}
- void VerifyLosses(QuicPacketSequenceNumber largest_observed,
- QuicPacketSequenceNumber* losses_expected,
+ void VerifyLosses(QuicPacketNumber largest_observed,
+ QuicPacketNumber* losses_expected,
size_t num_losses) {
- SequenceNumberSet lost_packets =
- loss_algorithm_.DetectLostPackets(
- unacked_packets_, clock_.Now(), largest_observed, rtt_stats_);
+ PacketNumberSet lost_packets = loss_algorithm_.DetectLostPackets(
+ unacked_packets_, clock_.Now(), largest_observed, rtt_stats_);
EXPECT_EQ(num_losses, lost_packets.size());
for (size_t i = 0; i < num_losses; ++i) {
EXPECT_TRUE(ContainsKey(lost_packets, losses_expected[i]));
@@ -98,7 +97,7 @@ TEST_F(TimeLossAlgorithmTest, NoLossUntilTimeout) {
unacked_packets_.NackPacket(1, 5);
VerifyLosses(2, nullptr, 0);
clock_.AdvanceTime(rtt_stats_.smoothed_rtt().Multiply(0.25));
- QuicPacketSequenceNumber lost[] = { 1 };
+ QuicPacketNumber lost[] = {1};
VerifyLosses(2, lost, arraysize(lost));
EXPECT_EQ(QuicTime::Zero(), loss_algorithm_.GetLossTimeout());
}
@@ -144,7 +143,7 @@ TEST_F(TimeLossAlgorithmTest, MultipleLossesAtOnce) {
EXPECT_EQ(rtt_stats_.smoothed_rtt().Multiply(0.25),
loss_algorithm_.GetLossTimeout().Subtract(clock_.Now()));
clock_.AdvanceTime(rtt_stats_.smoothed_rtt().Multiply(0.25));
- QuicPacketSequenceNumber lost[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
+ QuicPacketNumber lost[] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
VerifyLosses(10, lost, arraysize(lost));
EXPECT_EQ(QuicTime::Zero(), loss_algorithm_.GetLossTimeout());
}
generated by cgit v1.1 at 2025-03-30 19:27:38 +0000