blob: bfdf33891cd03d6b8622a67edc202c950db6dc2a [file] [log] [blame]
QUICHE teama6ef0a62019-03-07 20:34:33 -05001// Copyright 2013 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#include "net/third_party/quiche/src/quic/core/quic_received_packet_manager.h"
6
7#include <algorithm>
8#include <ostream>
9#include <vector>
10
11#include "net/third_party/quiche/src/quic/core/congestion_control/rtt_stats.h"
12#include "net/third_party/quiche/src/quic/core/crypto/crypto_protocol.h"
13#include "net/third_party/quiche/src/quic/core/quic_connection_stats.h"
ianswett0335e4e2020-01-16 17:23:38 -080014#include "net/third_party/quiche/src/quic/core/quic_constants.h"
QUICHE teama6ef0a62019-03-07 20:34:33 -050015#include "net/third_party/quiche/src/quic/platform/api/quic_expect_bug.h"
ianswett0335e4e2020-01-16 17:23:38 -080016#include "net/third_party/quiche/src/quic/platform/api/quic_flags.h"
QUICHE teama6ef0a62019-03-07 20:34:33 -050017#include "net/third_party/quiche/src/quic/platform/api/quic_test.h"
18#include "net/third_party/quiche/src/quic/test_tools/mock_clock.h"
19
20namespace quic {
21namespace test {
22
23class QuicReceivedPacketManagerPeer {
24 public:
25 static void SetAckMode(QuicReceivedPacketManager* manager, AckMode ack_mode) {
26 manager->ack_mode_ = ack_mode;
27 }
28
29 static void SetFastAckAfterQuiescence(QuicReceivedPacketManager* manager,
30 bool fast_ack_after_quiescence) {
31 manager->fast_ack_after_quiescence_ = fast_ack_after_quiescence;
32 }
33
ianswett95cf3832020-01-21 07:58:25 -080034 static void SetOneImmediateAck(QuicReceivedPacketManager* manager,
35 bool one_immediate_ack) {
36 manager->one_immediate_ack_ = one_immediate_ack;
37 }
38
QUICHE teama6ef0a62019-03-07 20:34:33 -050039 static void SetAckDecimationDelay(QuicReceivedPacketManager* manager,
40 float ack_decimation_delay) {
41 manager->ack_decimation_delay_ = ack_decimation_delay;
42 }
43};
44
45namespace {
46
47const bool kInstigateAck = true;
48const QuicTime::Delta kMinRttMs = QuicTime::Delta::FromMilliseconds(40);
49const QuicTime::Delta kDelayedAckTime =
50 QuicTime::Delta::FromMilliseconds(kDefaultDelayedAckTimeMs);
51
52struct TestParams {
53 explicit TestParams(QuicTransportVersion version) : version(version) {}
54
QUICHE teama6ef0a62019-03-07 20:34:33 -050055 QuicTransportVersion version;
56};
57
dschinazi142051a2019-09-18 18:17:29 -070058// Used by ::testing::PrintToStringParamName().
59std::string PrintToString(const TestParams& p) {
60 return QuicVersionToString(p.version);
61}
62
QUICHE teama6ef0a62019-03-07 20:34:33 -050063std::vector<TestParams> GetTestParams() {
64 std::vector<TestParams> params;
65 QuicTransportVersionVector all_supported_versions =
66 AllSupportedTransportVersions();
67 for (size_t i = 0; i < all_supported_versions.size(); ++i) {
68 params.push_back(TestParams(all_supported_versions[i]));
69 }
70 return params;
71}
72
73class QuicReceivedPacketManagerTest : public QuicTestWithParam<TestParams> {
74 protected:
75 QuicReceivedPacketManagerTest() : received_manager_(&stats_) {
76 clock_.AdvanceTime(QuicTime::Delta::FromSeconds(1));
77 rtt_stats_.UpdateRtt(kMinRttMs, QuicTime::Delta::Zero(), QuicTime::Zero());
78 received_manager_.set_save_timestamps(true);
79 }
80
81 void RecordPacketReceipt(uint64_t packet_number) {
82 RecordPacketReceipt(packet_number, QuicTime::Zero());
83 }
84
85 void RecordPacketReceipt(uint64_t packet_number, QuicTime receipt_time) {
86 QuicPacketHeader header;
87 header.packet_number = QuicPacketNumber(packet_number);
88 received_manager_.RecordPacketReceived(header, receipt_time);
89 }
90
91 bool HasPendingAck() {
QUICHE teama6ef0a62019-03-07 20:34:33 -050092 return received_manager_.ack_timeout().IsInitialized();
93 }
94
95 void MaybeUpdateAckTimeout(bool should_last_packet_instigate_acks,
96 uint64_t last_received_packet_number) {
QUICHE teama6ef0a62019-03-07 20:34:33 -050097 received_manager_.MaybeUpdateAckTimeout(
98 should_last_packet_instigate_acks,
99 QuicPacketNumber(last_received_packet_number), clock_.ApproximateNow(),
ianswett309987e2019-08-02 13:16:26 -0700100 clock_.ApproximateNow(), &rtt_stats_);
QUICHE teama6ef0a62019-03-07 20:34:33 -0500101 }
102
103 void CheckAckTimeout(QuicTime time) {
bncbe885272020-01-16 11:10:48 -0800104 DCHECK(HasPendingAck());
105 DCHECK_EQ(received_manager_.ack_timeout(), time);
QUICHE teama6ef0a62019-03-07 20:34:33 -0500106 if (time <= clock_.ApproximateNow()) {
107 // ACK timeout expires, send an ACK.
108 received_manager_.ResetAckStates();
109 DCHECK(!HasPendingAck());
110 }
111 }
112
113 MockClock clock_;
114 RttStats rtt_stats_;
115 QuicConnectionStats stats_;
116 QuicReceivedPacketManager received_manager_;
117};
118
119INSTANTIATE_TEST_SUITE_P(QuicReceivedPacketManagerTest,
120 QuicReceivedPacketManagerTest,
dschinazi142051a2019-09-18 18:17:29 -0700121 ::testing::ValuesIn(GetTestParams()),
122 ::testing::PrintToStringParamName());
QUICHE teama6ef0a62019-03-07 20:34:33 -0500123
124TEST_P(QuicReceivedPacketManagerTest, DontWaitForPacketsBefore) {
125 QuicPacketHeader header;
126 header.packet_number = QuicPacketNumber(2u);
127 received_manager_.RecordPacketReceived(header, QuicTime::Zero());
128 header.packet_number = QuicPacketNumber(7u);
129 received_manager_.RecordPacketReceived(header, QuicTime::Zero());
130 EXPECT_TRUE(received_manager_.IsAwaitingPacket(QuicPacketNumber(3u)));
131 EXPECT_TRUE(received_manager_.IsAwaitingPacket(QuicPacketNumber(6u)));
132 received_manager_.DontWaitForPacketsBefore(QuicPacketNumber(4));
133 EXPECT_FALSE(received_manager_.IsAwaitingPacket(QuicPacketNumber(3u)));
134 EXPECT_TRUE(received_manager_.IsAwaitingPacket(QuicPacketNumber(6u)));
135}
136
137TEST_P(QuicReceivedPacketManagerTest, GetUpdatedAckFrame) {
138 QuicPacketHeader header;
139 header.packet_number = QuicPacketNumber(2u);
140 QuicTime two_ms = QuicTime::Zero() + QuicTime::Delta::FromMilliseconds(2);
141 EXPECT_FALSE(received_manager_.ack_frame_updated());
142 received_manager_.RecordPacketReceived(header, two_ms);
143 EXPECT_TRUE(received_manager_.ack_frame_updated());
144
145 QuicFrame ack = received_manager_.GetUpdatedAckFrame(QuicTime::Zero());
fayangf477f732019-06-20 07:03:06 -0700146 received_manager_.ResetAckStates();
QUICHE teama6ef0a62019-03-07 20:34:33 -0500147 EXPECT_FALSE(received_manager_.ack_frame_updated());
148 // When UpdateReceivedPacketInfo with a time earlier than the time of the
149 // largest observed packet, make sure that the delta is 0, not negative.
150 EXPECT_EQ(QuicTime::Delta::Zero(), ack.ack_frame->ack_delay_time);
151 EXPECT_EQ(1u, ack.ack_frame->received_packet_times.size());
152
153 QuicTime four_ms = QuicTime::Zero() + QuicTime::Delta::FromMilliseconds(4);
154 ack = received_manager_.GetUpdatedAckFrame(four_ms);
fayangf477f732019-06-20 07:03:06 -0700155 received_manager_.ResetAckStates();
QUICHE teama6ef0a62019-03-07 20:34:33 -0500156 EXPECT_FALSE(received_manager_.ack_frame_updated());
157 // When UpdateReceivedPacketInfo after not having received a new packet,
158 // the delta should still be accurate.
159 EXPECT_EQ(QuicTime::Delta::FromMilliseconds(2),
160 ack.ack_frame->ack_delay_time);
161 // And received packet times won't have change.
162 EXPECT_EQ(1u, ack.ack_frame->received_packet_times.size());
163
164 header.packet_number = QuicPacketNumber(999u);
165 received_manager_.RecordPacketReceived(header, two_ms);
166 header.packet_number = QuicPacketNumber(4u);
167 received_manager_.RecordPacketReceived(header, two_ms);
168 header.packet_number = QuicPacketNumber(1000u);
169 received_manager_.RecordPacketReceived(header, two_ms);
170 EXPECT_TRUE(received_manager_.ack_frame_updated());
171 ack = received_manager_.GetUpdatedAckFrame(two_ms);
fayangf477f732019-06-20 07:03:06 -0700172 received_manager_.ResetAckStates();
QUICHE teama6ef0a62019-03-07 20:34:33 -0500173 EXPECT_FALSE(received_manager_.ack_frame_updated());
174 // UpdateReceivedPacketInfo should discard any times which can't be
175 // expressed on the wire.
176 EXPECT_EQ(2u, ack.ack_frame->received_packet_times.size());
177}
178
179TEST_P(QuicReceivedPacketManagerTest, UpdateReceivedConnectionStats) {
180 EXPECT_FALSE(received_manager_.ack_frame_updated());
181 RecordPacketReceipt(1);
182 EXPECT_TRUE(received_manager_.ack_frame_updated());
183 RecordPacketReceipt(6);
184 RecordPacketReceipt(2,
185 QuicTime::Zero() + QuicTime::Delta::FromMilliseconds(1));
186
187 EXPECT_EQ(4u, stats_.max_sequence_reordering);
188 EXPECT_EQ(1000, stats_.max_time_reordering_us);
189 EXPECT_EQ(1u, stats_.packets_reordered);
190}
191
192TEST_P(QuicReceivedPacketManagerTest, LimitAckRanges) {
193 received_manager_.set_max_ack_ranges(10);
194 EXPECT_FALSE(received_manager_.ack_frame_updated());
195 for (int i = 0; i < 100; ++i) {
196 RecordPacketReceipt(1 + 2 * i);
197 EXPECT_TRUE(received_manager_.ack_frame_updated());
198 received_manager_.GetUpdatedAckFrame(QuicTime::Zero());
199 EXPECT_GE(10u, received_manager_.ack_frame().packets.NumIntervals());
200 EXPECT_EQ(QuicPacketNumber(1u + 2 * i),
201 received_manager_.ack_frame().packets.Max());
202 for (int j = 0; j < std::min(10, i + 1); ++j) {
203 ASSERT_GE(i, j);
204 EXPECT_TRUE(received_manager_.ack_frame().packets.Contains(
205 QuicPacketNumber(1 + (i - j) * 2)));
206 if (i > j) {
207 EXPECT_FALSE(received_manager_.ack_frame().packets.Contains(
208 QuicPacketNumber((i - j) * 2)));
209 }
210 }
211 }
212}
213
214TEST_P(QuicReceivedPacketManagerTest, IgnoreOutOfOrderTimestamps) {
215 EXPECT_FALSE(received_manager_.ack_frame_updated());
216 RecordPacketReceipt(1, QuicTime::Zero());
217 EXPECT_TRUE(received_manager_.ack_frame_updated());
218 EXPECT_EQ(1u, received_manager_.ack_frame().received_packet_times.size());
219 RecordPacketReceipt(2,
220 QuicTime::Zero() + QuicTime::Delta::FromMilliseconds(1));
221 EXPECT_EQ(2u, received_manager_.ack_frame().received_packet_times.size());
222 RecordPacketReceipt(3, QuicTime::Zero());
223 EXPECT_EQ(2u, received_manager_.ack_frame().received_packet_times.size());
224}
225
226TEST_P(QuicReceivedPacketManagerTest, HasMissingPackets) {
fayang6dba4902019-06-17 10:04:23 -0700227 EXPECT_QUIC_BUG(received_manager_.PeerFirstSendingPacketNumber(),
228 "No packets have been received yet");
QUICHE teama6ef0a62019-03-07 20:34:33 -0500229 RecordPacketReceipt(4, QuicTime::Zero());
fayang6dba4902019-06-17 10:04:23 -0700230 EXPECT_EQ(QuicPacketNumber(4),
231 received_manager_.PeerFirstSendingPacketNumber());
232 EXPECT_FALSE(received_manager_.HasMissingPackets());
QUICHE teama6ef0a62019-03-07 20:34:33 -0500233 RecordPacketReceipt(3, QuicTime::Zero());
fayang6dba4902019-06-17 10:04:23 -0700234 EXPECT_FALSE(received_manager_.HasMissingPackets());
235 EXPECT_EQ(QuicPacketNumber(3),
236 received_manager_.PeerFirstSendingPacketNumber());
QUICHE teama6ef0a62019-03-07 20:34:33 -0500237 RecordPacketReceipt(1, QuicTime::Zero());
238 EXPECT_EQ(QuicPacketNumber(1),
239 received_manager_.PeerFirstSendingPacketNumber());
240 EXPECT_TRUE(received_manager_.HasMissingPackets());
241 RecordPacketReceipt(2, QuicTime::Zero());
242 EXPECT_EQ(QuicPacketNumber(1),
243 received_manager_.PeerFirstSendingPacketNumber());
244 EXPECT_FALSE(received_manager_.HasMissingPackets());
245}
246
247TEST_P(QuicReceivedPacketManagerTest, OutOfOrderReceiptCausesAckSent) {
QUICHE teama6ef0a62019-03-07 20:34:33 -0500248 EXPECT_FALSE(HasPendingAck());
249
250 RecordPacketReceipt(3, clock_.ApproximateNow());
251 MaybeUpdateAckTimeout(kInstigateAck, 3);
fayang6dba4902019-06-17 10:04:23 -0700252 // Delayed ack is scheduled.
253 CheckAckTimeout(clock_.ApproximateNow() + kDelayedAckTime);
QUICHE teama6ef0a62019-03-07 20:34:33 -0500254
ianswett95cf3832020-01-21 07:58:25 -0800255 RecordPacketReceipt(5, clock_.ApproximateNow());
256 MaybeUpdateAckTimeout(kInstigateAck, 5);
257 // Immediate ack is sent.
258 CheckAckTimeout(clock_.ApproximateNow());
259
260 RecordPacketReceipt(6, clock_.ApproximateNow());
261 MaybeUpdateAckTimeout(kInstigateAck, 6);
262 // Immediate ack is scheduled, because 4 is still missing.
263 CheckAckTimeout(clock_.ApproximateNow());
264
QUICHE teama6ef0a62019-03-07 20:34:33 -0500265 RecordPacketReceipt(2, clock_.ApproximateNow());
266 MaybeUpdateAckTimeout(kInstigateAck, 2);
267 CheckAckTimeout(clock_.ApproximateNow());
268
269 RecordPacketReceipt(1, clock_.ApproximateNow());
270 MaybeUpdateAckTimeout(kInstigateAck, 1);
271 // Should ack immediately, since this fills the last hole.
272 CheckAckTimeout(clock_.ApproximateNow());
273
ianswett95cf3832020-01-21 07:58:25 -0800274 RecordPacketReceipt(7, clock_.ApproximateNow());
275 MaybeUpdateAckTimeout(kInstigateAck, 7);
276 // Immediate ack is scheduled, because 4 is still missing.
277 CheckAckTimeout(clock_.ApproximateNow());
278}
279
280TEST_P(QuicReceivedPacketManagerTest, OutOfOrderReceiptCausesAckSent1Ack) {
281 QuicReceivedPacketManagerPeer::SetOneImmediateAck(&received_manager_, true);
282 EXPECT_FALSE(HasPendingAck());
283
284 RecordPacketReceipt(3, clock_.ApproximateNow());
285 MaybeUpdateAckTimeout(kInstigateAck, 3);
QUICHE teama6ef0a62019-03-07 20:34:33 -0500286 // Delayed ack is scheduled.
287 CheckAckTimeout(clock_.ApproximateNow() + kDelayedAckTime);
ianswett95cf3832020-01-21 07:58:25 -0800288
289 RecordPacketReceipt(5, clock_.ApproximateNow());
290 MaybeUpdateAckTimeout(kInstigateAck, 5);
291 // Immediate ack is sent.
292 CheckAckTimeout(clock_.ApproximateNow());
293
294 RecordPacketReceipt(6, clock_.ApproximateNow());
295 MaybeUpdateAckTimeout(kInstigateAck, 6);
296 // Delayed ack is scheduled.
297 CheckAckTimeout(clock_.ApproximateNow() + kDelayedAckTime);
298
299 RecordPacketReceipt(2, clock_.ApproximateNow());
300 MaybeUpdateAckTimeout(kInstigateAck, 2);
301 CheckAckTimeout(clock_.ApproximateNow());
302
303 RecordPacketReceipt(1, clock_.ApproximateNow());
304 MaybeUpdateAckTimeout(kInstigateAck, 1);
305 // Should ack immediately, since this fills the last hole.
306 CheckAckTimeout(clock_.ApproximateNow());
307
308 RecordPacketReceipt(7, clock_.ApproximateNow());
309 MaybeUpdateAckTimeout(kInstigateAck, 7);
310 // Delayed ack is scheduled, even though 4 is still missing.
311 CheckAckTimeout(clock_.ApproximateNow() + kDelayedAckTime);
QUICHE teama6ef0a62019-03-07 20:34:33 -0500312}
313
314TEST_P(QuicReceivedPacketManagerTest, OutOfOrderAckReceiptCausesNoAck) {
QUICHE teama6ef0a62019-03-07 20:34:33 -0500315 EXPECT_FALSE(HasPendingAck());
316
317 RecordPacketReceipt(2, clock_.ApproximateNow());
318 MaybeUpdateAckTimeout(!kInstigateAck, 2);
319 EXPECT_FALSE(HasPendingAck());
320
321 RecordPacketReceipt(1, clock_.ApproximateNow());
322 MaybeUpdateAckTimeout(!kInstigateAck, 1);
323 EXPECT_FALSE(HasPendingAck());
324}
325
326TEST_P(QuicReceivedPacketManagerTest, AckReceiptCausesAckSend) {
QUICHE teama6ef0a62019-03-07 20:34:33 -0500327 EXPECT_FALSE(HasPendingAck());
328
329 RecordPacketReceipt(1, clock_.ApproximateNow());
330 MaybeUpdateAckTimeout(!kInstigateAck, 1);
331 EXPECT_FALSE(HasPendingAck());
332
333 RecordPacketReceipt(2, clock_.ApproximateNow());
334 MaybeUpdateAckTimeout(!kInstigateAck, 2);
335 EXPECT_FALSE(HasPendingAck());
336
337 RecordPacketReceipt(3, clock_.ApproximateNow());
338 MaybeUpdateAckTimeout(kInstigateAck, 3);
339 // Delayed ack is scheduled.
340 CheckAckTimeout(clock_.ApproximateNow() + kDelayedAckTime);
341 clock_.AdvanceTime(kDelayedAckTime);
342 CheckAckTimeout(clock_.ApproximateNow());
343
344 RecordPacketReceipt(4, clock_.ApproximateNow());
345 MaybeUpdateAckTimeout(!kInstigateAck, 4);
346 EXPECT_FALSE(HasPendingAck());
347
348 RecordPacketReceipt(5, clock_.ApproximateNow());
349 MaybeUpdateAckTimeout(!kInstigateAck, 5);
350 EXPECT_FALSE(HasPendingAck());
351}
352
353TEST_P(QuicReceivedPacketManagerTest, AckSentEveryNthPacket) {
QUICHE teama6ef0a62019-03-07 20:34:33 -0500354 EXPECT_FALSE(HasPendingAck());
355 received_manager_.set_ack_frequency_before_ack_decimation(3);
356
357 // Receives packets 1 - 39.
358 for (size_t i = 1; i <= 39; ++i) {
359 RecordPacketReceipt(i, clock_.ApproximateNow());
360 MaybeUpdateAckTimeout(kInstigateAck, i);
361 if (i % 3 == 0) {
362 CheckAckTimeout(clock_.ApproximateNow());
363 } else {
364 CheckAckTimeout(clock_.ApproximateNow() + kDelayedAckTime);
365 }
366 }
367}
368
369TEST_P(QuicReceivedPacketManagerTest, AckDecimationReducesAcks) {
QUICHE teama6ef0a62019-03-07 20:34:33 -0500370 EXPECT_FALSE(HasPendingAck());
371 QuicReceivedPacketManagerPeer::SetAckMode(&received_manager_,
372 ACK_DECIMATION_WITH_REORDERING);
373
374 // Start ack decimation from 10th packet.
375 received_manager_.set_min_received_before_ack_decimation(10);
376
377 // Receives packets 1 - 29.
378 for (size_t i = 1; i <= 29; ++i) {
379 RecordPacketReceipt(i, clock_.ApproximateNow());
380 MaybeUpdateAckTimeout(kInstigateAck, i);
381 if (i <= 10) {
382 // For packets 1-10, ack every 2 packets.
383 if (i % 2 == 0) {
384 CheckAckTimeout(clock_.ApproximateNow());
385 } else {
386 CheckAckTimeout(clock_.ApproximateNow() + kDelayedAckTime);
387 }
388 continue;
389 }
390 // ack at 20.
391 if (i == 20) {
392 CheckAckTimeout(clock_.ApproximateNow());
393 } else {
394 CheckAckTimeout(clock_.ApproximateNow() + kMinRttMs * 0.25);
395 }
396 }
397
398 // We now receive the 30th packet, and so we send an ack.
399 RecordPacketReceipt(30, clock_.ApproximateNow());
400 MaybeUpdateAckTimeout(kInstigateAck, 30);
401 CheckAckTimeout(clock_.ApproximateNow());
402}
403
404TEST_P(QuicReceivedPacketManagerTest, SendDelayedAfterQuiescence) {
QUICHE teama6ef0a62019-03-07 20:34:33 -0500405 EXPECT_FALSE(HasPendingAck());
406 QuicReceivedPacketManagerPeer::SetFastAckAfterQuiescence(&received_manager_,
407 true);
408 // The beginning of the connection counts as quiescence.
409 QuicTime ack_time =
410 clock_.ApproximateNow() + QuicTime::Delta::FromMilliseconds(1);
411
412 RecordPacketReceipt(1, clock_.ApproximateNow());
413 MaybeUpdateAckTimeout(kInstigateAck, 1);
414 CheckAckTimeout(ack_time);
415 // Simulate delayed ack alarm firing.
416 clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(1));
417 CheckAckTimeout(clock_.ApproximateNow());
418
419 // Process another packet immediately after sending the ack and expect the
420 // ack timeout to be set delayed ack time in the future.
421 ack_time = clock_.ApproximateNow() + kDelayedAckTime;
422 RecordPacketReceipt(2, clock_.ApproximateNow());
423 MaybeUpdateAckTimeout(kInstigateAck, 2);
424 CheckAckTimeout(ack_time);
425 // Simulate delayed ack alarm firing.
426 clock_.AdvanceTime(kDelayedAckTime);
427 CheckAckTimeout(clock_.ApproximateNow());
428
429 // Wait 1 second and enesure the ack timeout is set to 1ms in the future.
430 clock_.AdvanceTime(QuicTime::Delta::FromSeconds(1));
431 ack_time = clock_.ApproximateNow() + QuicTime::Delta::FromMilliseconds(1);
432 RecordPacketReceipt(3, clock_.ApproximateNow());
433 MaybeUpdateAckTimeout(kInstigateAck, 3);
434 CheckAckTimeout(ack_time);
435}
436
437TEST_P(QuicReceivedPacketManagerTest, SendDelayedAckDecimation) {
QUICHE teama6ef0a62019-03-07 20:34:33 -0500438 EXPECT_FALSE(HasPendingAck());
439 QuicReceivedPacketManagerPeer::SetAckMode(&received_manager_, ACK_DECIMATION);
440 // The ack time should be based on min_rtt * 1/4, since it's less than the
441 // default delayed ack time.
442 QuicTime ack_time = clock_.ApproximateNow() + kMinRttMs * 0.25;
443
444 // Process all the packets in order so there aren't missing packets.
445 uint64_t kFirstDecimatedPacket = 101;
446 for (uint64_t i = 1; i < kFirstDecimatedPacket; ++i) {
447 RecordPacketReceipt(i, clock_.ApproximateNow());
448 MaybeUpdateAckTimeout(kInstigateAck, i);
449 if (i % 2 == 0) {
450 // Ack every 2 packets by default.
451 CheckAckTimeout(clock_.ApproximateNow());
452 } else {
453 CheckAckTimeout(clock_.ApproximateNow() + kDelayedAckTime);
454 }
455 }
456
457 RecordPacketReceipt(kFirstDecimatedPacket, clock_.ApproximateNow());
458 MaybeUpdateAckTimeout(kInstigateAck, kFirstDecimatedPacket);
459 CheckAckTimeout(ack_time);
460
461 // The 10th received packet causes an ack to be sent.
462 for (uint64_t i = 1; i < 10; ++i) {
463 RecordPacketReceipt(kFirstDecimatedPacket + i, clock_.ApproximateNow());
464 MaybeUpdateAckTimeout(kInstigateAck, kFirstDecimatedPacket + i);
465 }
466 CheckAckTimeout(clock_.ApproximateNow());
467}
468
ianswett0335e4e2020-01-16 17:23:38 -0800469TEST_P(QuicReceivedPacketManagerTest, SendDelayedAckDecimationMin1ms) {
470 if (!GetQuicReloadableFlag(quic_ack_delay_alarm_granularity)) {
471 return;
472 }
473 EXPECT_FALSE(HasPendingAck());
474 QuicReceivedPacketManagerPeer::SetAckMode(&received_manager_, ACK_DECIMATION);
475 // Seed the min_rtt with a kAlarmGranularity signal.
476 rtt_stats_.UpdateRtt(kAlarmGranularity, QuicTime::Delta::Zero(),
477 clock_.ApproximateNow());
478 // The ack time should be based on kAlarmGranularity, since the RTT is 1ms.
479 QuicTime ack_time = clock_.ApproximateNow() + kAlarmGranularity;
480
481 // Process all the packets in order so there aren't missing packets.
482 uint64_t kFirstDecimatedPacket = 101;
483 for (uint64_t i = 1; i < kFirstDecimatedPacket; ++i) {
484 RecordPacketReceipt(i, clock_.ApproximateNow());
485 MaybeUpdateAckTimeout(kInstigateAck, i);
486 if (i % 2 == 0) {
487 // Ack every 2 packets by default.
488 CheckAckTimeout(clock_.ApproximateNow());
489 } else {
490 CheckAckTimeout(clock_.ApproximateNow() + kDelayedAckTime);
491 }
492 }
493
494 RecordPacketReceipt(kFirstDecimatedPacket, clock_.ApproximateNow());
495 MaybeUpdateAckTimeout(kInstigateAck, kFirstDecimatedPacket);
496 CheckAckTimeout(ack_time);
497
498 // The 10th received packet causes an ack to be sent.
499 for (uint64_t i = 1; i < 10; ++i) {
500 RecordPacketReceipt(kFirstDecimatedPacket + i, clock_.ApproximateNow());
501 MaybeUpdateAckTimeout(kInstigateAck, kFirstDecimatedPacket + i);
502 }
503 CheckAckTimeout(clock_.ApproximateNow());
504}
505
QUICHE teama6ef0a62019-03-07 20:34:33 -0500506TEST_P(QuicReceivedPacketManagerTest,
507 SendDelayedAckAckDecimationAfterQuiescence) {
QUICHE teama6ef0a62019-03-07 20:34:33 -0500508 EXPECT_FALSE(HasPendingAck());
509 QuicReceivedPacketManagerPeer::SetAckMode(&received_manager_, ACK_DECIMATION);
510 QuicReceivedPacketManagerPeer::SetFastAckAfterQuiescence(&received_manager_,
511 true);
512 // The beginning of the connection counts as quiescence.
513 QuicTime ack_time =
514 clock_.ApproximateNow() + QuicTime::Delta::FromMilliseconds(1);
515 RecordPacketReceipt(1, clock_.ApproximateNow());
516 MaybeUpdateAckTimeout(kInstigateAck, 1);
517 CheckAckTimeout(ack_time);
518 // Simulate delayed ack alarm firing.
519 clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(1));
520 CheckAckTimeout(clock_.ApproximateNow());
521
522 // Process another packet immedately after sending the ack and expect the
523 // ack timeout to be set delayed ack time in the future.
524 ack_time = clock_.ApproximateNow() + kDelayedAckTime;
525 RecordPacketReceipt(2, clock_.ApproximateNow());
526 MaybeUpdateAckTimeout(kInstigateAck, 2);
527 CheckAckTimeout(ack_time);
528 // Simulate delayed ack alarm firing.
529 clock_.AdvanceTime(kDelayedAckTime);
530 CheckAckTimeout(clock_.ApproximateNow());
531
532 // Wait 1 second and enesure the ack timeout is set to 1ms in the future.
533 clock_.AdvanceTime(QuicTime::Delta::FromSeconds(1));
534 ack_time = clock_.ApproximateNow() + QuicTime::Delta::FromMilliseconds(1);
535 RecordPacketReceipt(3, clock_.ApproximateNow());
536 MaybeUpdateAckTimeout(kInstigateAck, 3);
537 CheckAckTimeout(ack_time);
538 // Process enough packets to get into ack decimation behavior.
539 // The ack time should be based on min_rtt/4, since it's less than the
540 // default delayed ack time.
541 ack_time = clock_.ApproximateNow() + kMinRttMs * 0.25;
542 uint64_t kFirstDecimatedPacket = 101;
543 for (uint64_t i = 4; i < kFirstDecimatedPacket; ++i) {
544 RecordPacketReceipt(i, clock_.ApproximateNow());
545 MaybeUpdateAckTimeout(kInstigateAck, i);
546 if (i % 2 == 0) {
547 // Ack every 2 packets by default.
548 CheckAckTimeout(clock_.ApproximateNow());
549 } else {
550 CheckAckTimeout(clock_.ApproximateNow() + kDelayedAckTime);
551 }
552 }
553 EXPECT_FALSE(HasPendingAck());
554 RecordPacketReceipt(kFirstDecimatedPacket, clock_.ApproximateNow());
555 MaybeUpdateAckTimeout(kInstigateAck, kFirstDecimatedPacket);
556 CheckAckTimeout(ack_time);
557
558 // The 10th received packet causes an ack to be sent.
559 for (uint64_t i = 1; i < 10; ++i) {
560 RecordPacketReceipt(kFirstDecimatedPacket + i, clock_.ApproximateNow());
561 MaybeUpdateAckTimeout(kInstigateAck, kFirstDecimatedPacket + i);
562 }
563 CheckAckTimeout(clock_.ApproximateNow());
564
565 // Wait 1 second and enesure the ack timeout is set to 1ms in the future.
566 clock_.AdvanceTime(QuicTime::Delta::FromSeconds(1));
567 ack_time = clock_.ApproximateNow() + QuicTime::Delta::FromMilliseconds(1);
568 RecordPacketReceipt(kFirstDecimatedPacket + 10, clock_.ApproximateNow());
569 MaybeUpdateAckTimeout(kInstigateAck, kFirstDecimatedPacket + 10);
570 CheckAckTimeout(ack_time);
571}
572
573TEST_P(QuicReceivedPacketManagerTest,
574 SendDelayedAckDecimationUnlimitedAggregation) {
QUICHE teama6ef0a62019-03-07 20:34:33 -0500575 EXPECT_FALSE(HasPendingAck());
576 QuicConfig config;
577 QuicTagVector connection_options;
578 connection_options.push_back(kACKD);
579 // No limit on the number of packets received before sending an ack.
580 connection_options.push_back(kAKDU);
581 config.SetConnectionOptionsToSend(connection_options);
582 received_manager_.SetFromConfig(config, Perspective::IS_CLIENT);
583
584 // The ack time should be based on min_rtt/4, since it's less than the
585 // default delayed ack time.
586 QuicTime ack_time = clock_.ApproximateNow() + kMinRttMs * 0.25;
587
588 // Process all the initial packets in order so there aren't missing packets.
589 uint64_t kFirstDecimatedPacket = 101;
590 for (uint64_t i = 1; i < kFirstDecimatedPacket; ++i) {
591 RecordPacketReceipt(i, clock_.ApproximateNow());
592 MaybeUpdateAckTimeout(kInstigateAck, i);
593 if (i % 2 == 0) {
594 // Ack every 2 packets by default.
595 CheckAckTimeout(clock_.ApproximateNow());
596 } else {
597 CheckAckTimeout(clock_.ApproximateNow() + kDelayedAckTime);
598 }
599 }
600
601 RecordPacketReceipt(kFirstDecimatedPacket, clock_.ApproximateNow());
602 MaybeUpdateAckTimeout(kInstigateAck, kFirstDecimatedPacket);
603 CheckAckTimeout(ack_time);
604
605 // 18 packets will not cause an ack to be sent. 19 will because when
606 // stop waiting frames are in use, we ack every 20 packets no matter what.
607 for (int i = 1; i <= 18; ++i) {
608 RecordPacketReceipt(kFirstDecimatedPacket + i, clock_.ApproximateNow());
609 MaybeUpdateAckTimeout(kInstigateAck, kFirstDecimatedPacket + i);
610 }
611 CheckAckTimeout(ack_time);
612}
613
614TEST_P(QuicReceivedPacketManagerTest, SendDelayedAckDecimationEighthRtt) {
QUICHE teama6ef0a62019-03-07 20:34:33 -0500615 EXPECT_FALSE(HasPendingAck());
616 QuicReceivedPacketManagerPeer::SetAckMode(&received_manager_, ACK_DECIMATION);
617 QuicReceivedPacketManagerPeer::SetAckDecimationDelay(&received_manager_,
618 0.125);
619
620 // The ack time should be based on min_rtt/8, since it's less than the
621 // default delayed ack time.
622 QuicTime ack_time = clock_.ApproximateNow() + kMinRttMs * 0.125;
623
624 // Process all the packets in order so there aren't missing packets.
625 uint64_t kFirstDecimatedPacket = 101;
626 for (uint64_t i = 1; i < kFirstDecimatedPacket; ++i) {
627 RecordPacketReceipt(i, clock_.ApproximateNow());
628 MaybeUpdateAckTimeout(kInstigateAck, i);
629 if (i % 2 == 0) {
630 // Ack every 2 packets by default.
631 CheckAckTimeout(clock_.ApproximateNow());
632 } else {
633 CheckAckTimeout(clock_.ApproximateNow() + kDelayedAckTime);
634 }
635 }
636
637 RecordPacketReceipt(kFirstDecimatedPacket, clock_.ApproximateNow());
638 MaybeUpdateAckTimeout(kInstigateAck, kFirstDecimatedPacket);
639 CheckAckTimeout(ack_time);
640
641 // The 10th received packet causes an ack to be sent.
642 for (uint64_t i = 1; i < 10; ++i) {
643 RecordPacketReceipt(kFirstDecimatedPacket + i, clock_.ApproximateNow());
644 MaybeUpdateAckTimeout(kInstigateAck, kFirstDecimatedPacket + i);
645 }
646 CheckAckTimeout(clock_.ApproximateNow());
647}
648
649TEST_P(QuicReceivedPacketManagerTest, SendDelayedAckDecimationWithReordering) {
QUICHE teama6ef0a62019-03-07 20:34:33 -0500650 EXPECT_FALSE(HasPendingAck());
651 QuicReceivedPacketManagerPeer::SetAckMode(&received_manager_,
652 ACK_DECIMATION_WITH_REORDERING);
653
654 // The ack time should be based on min_rtt/4, since it's less than the
655 // default delayed ack time.
656 QuicTime ack_time = clock_.ApproximateNow() + kMinRttMs * 0.25;
657 // Process all the packets in order so there aren't missing packets.
658 uint64_t kFirstDecimatedPacket = 101;
659 for (uint64_t i = 1; i < kFirstDecimatedPacket; ++i) {
660 RecordPacketReceipt(i, clock_.ApproximateNow());
661 MaybeUpdateAckTimeout(kInstigateAck, i);
662 if (i % 2 == 0) {
663 // Ack every 2 packets by default.
664 CheckAckTimeout(clock_.ApproximateNow());
665 } else {
666 CheckAckTimeout(clock_.ApproximateNow() + kDelayedAckTime);
667 }
668 }
669
670 // Receive one packet out of order and then the rest in order.
671 // The loop leaves a one packet gap between acks sent to simulate some loss.
672 for (int j = 0; j < 3; ++j) {
673 // Process packet 10 first and ensure the timeout is one eighth min_rtt.
674 RecordPacketReceipt(kFirstDecimatedPacket + 9 + (j * 11),
675 clock_.ApproximateNow());
676 MaybeUpdateAckTimeout(kInstigateAck, kFirstDecimatedPacket + 9 + (j * 11));
677 ack_time = clock_.ApproximateNow() + QuicTime::Delta::FromMilliseconds(5);
678 CheckAckTimeout(ack_time);
679
680 // The 10th received packet causes an ack to be sent.
681 for (int i = 0; i < 9; ++i) {
682 RecordPacketReceipt(kFirstDecimatedPacket + i + (j * 11),
683 clock_.ApproximateNow());
684 MaybeUpdateAckTimeout(kInstigateAck,
685 kFirstDecimatedPacket + i + (j * 11));
686 }
687 CheckAckTimeout(clock_.ApproximateNow());
688 }
689}
690
691TEST_P(QuicReceivedPacketManagerTest,
692 SendDelayedAckDecimationWithLargeReordering) {
QUICHE teama6ef0a62019-03-07 20:34:33 -0500693 EXPECT_FALSE(HasPendingAck());
694 QuicReceivedPacketManagerPeer::SetAckMode(&received_manager_,
695 ACK_DECIMATION_WITH_REORDERING);
696 // The ack time should be based on min_rtt/4, since it's less than the
697 // default delayed ack time.
698 QuicTime ack_time = clock_.ApproximateNow() + kMinRttMs * 0.25;
699
700 // Process all the packets in order so there aren't missing packets.
701 uint64_t kFirstDecimatedPacket = 101;
702 for (uint64_t i = 1; i < kFirstDecimatedPacket; ++i) {
703 RecordPacketReceipt(i, clock_.ApproximateNow());
704 MaybeUpdateAckTimeout(kInstigateAck, i);
705 if (i % 2 == 0) {
706 // Ack every 2 packets by default.
707 CheckAckTimeout(clock_.ApproximateNow());
708 } else {
709 CheckAckTimeout(clock_.ApproximateNow() + kDelayedAckTime);
710 }
711 }
712
713 RecordPacketReceipt(kFirstDecimatedPacket, clock_.ApproximateNow());
714 MaybeUpdateAckTimeout(kInstigateAck, kFirstDecimatedPacket);
715 CheckAckTimeout(ack_time);
716
717 RecordPacketReceipt(kFirstDecimatedPacket + 19, clock_.ApproximateNow());
718 MaybeUpdateAckTimeout(kInstigateAck, kFirstDecimatedPacket + 19);
719 ack_time = clock_.ApproximateNow() + kMinRttMs * 0.125;
720 CheckAckTimeout(ack_time);
721
722 // The 10th received packet causes an ack to be sent.
723 for (int i = 1; i < 9; ++i) {
724 RecordPacketReceipt(kFirstDecimatedPacket + i, clock_.ApproximateNow());
725 MaybeUpdateAckTimeout(kInstigateAck, kFirstDecimatedPacket + i);
726 }
727 CheckAckTimeout(clock_.ApproximateNow());
728
729 // The next packet received in order will cause an immediate ack, because it
730 // fills a hole.
731 RecordPacketReceipt(kFirstDecimatedPacket + 10, clock_.ApproximateNow());
732 MaybeUpdateAckTimeout(kInstigateAck, kFirstDecimatedPacket + 10);
733 CheckAckTimeout(clock_.ApproximateNow());
734}
735
736TEST_P(QuicReceivedPacketManagerTest,
737 SendDelayedAckDecimationWithReorderingEighthRtt) {
QUICHE teama6ef0a62019-03-07 20:34:33 -0500738 EXPECT_FALSE(HasPendingAck());
739 QuicReceivedPacketManagerPeer::SetAckMode(&received_manager_,
740 ACK_DECIMATION_WITH_REORDERING);
741 QuicReceivedPacketManagerPeer::SetAckDecimationDelay(&received_manager_,
742 0.125);
743 // The ack time should be based on min_rtt/8, since it's less than the
744 // default delayed ack time.
745 QuicTime ack_time = clock_.ApproximateNow() + kMinRttMs * 0.125;
746
747 // Process all the packets in order so there aren't missing packets.
748 uint64_t kFirstDecimatedPacket = 101;
749 for (uint64_t i = 1; i < kFirstDecimatedPacket; ++i) {
750 RecordPacketReceipt(i, clock_.ApproximateNow());
751 MaybeUpdateAckTimeout(kInstigateAck, i);
752 if (i % 2 == 0) {
753 // Ack every 2 packets by default.
754 CheckAckTimeout(clock_.ApproximateNow());
755 } else {
756 CheckAckTimeout(clock_.ApproximateNow() + kDelayedAckTime);
757 }
758 }
759
760 RecordPacketReceipt(kFirstDecimatedPacket, clock_.ApproximateNow());
761 MaybeUpdateAckTimeout(kInstigateAck, kFirstDecimatedPacket);
762 CheckAckTimeout(ack_time);
763
764 // Process packet 10 first and ensure the timeout is one eighth min_rtt.
765 RecordPacketReceipt(kFirstDecimatedPacket + 9, clock_.ApproximateNow());
766 MaybeUpdateAckTimeout(kInstigateAck, kFirstDecimatedPacket + 9);
767 CheckAckTimeout(ack_time);
768
769 // The 10th received packet causes an ack to be sent.
770 for (int i = 1; i < 9; ++i) {
771 RecordPacketReceipt(kFirstDecimatedPacket + i, clock_.ApproximateNow());
772 MaybeUpdateAckTimeout(kInstigateAck + i, kFirstDecimatedPacket);
773 }
774 CheckAckTimeout(clock_.ApproximateNow());
775}
776
777TEST_P(QuicReceivedPacketManagerTest,
778 SendDelayedAckDecimationWithLargeReorderingEighthRtt) {
QUICHE teama6ef0a62019-03-07 20:34:33 -0500779 EXPECT_FALSE(HasPendingAck());
780 QuicReceivedPacketManagerPeer::SetAckMode(&received_manager_,
781 ACK_DECIMATION_WITH_REORDERING);
782 QuicReceivedPacketManagerPeer::SetAckDecimationDelay(&received_manager_,
783 0.125);
784
785 // The ack time should be based on min_rtt/8, since it's less than the
786 // default delayed ack time.
787 QuicTime ack_time = clock_.ApproximateNow() + kMinRttMs * 0.125;
788 // Process all the packets in order so there aren't missing packets.
789 uint64_t kFirstDecimatedPacket = 101;
790 for (uint64_t i = 1; i < kFirstDecimatedPacket; ++i) {
791 RecordPacketReceipt(i, clock_.ApproximateNow());
792 MaybeUpdateAckTimeout(kInstigateAck, i);
793 if (i % 2 == 0) {
794 // Ack every 2 packets by default.
795 CheckAckTimeout(clock_.ApproximateNow());
796 } else {
797 CheckAckTimeout(clock_.ApproximateNow() + kDelayedAckTime);
798 }
799 }
800
801 RecordPacketReceipt(kFirstDecimatedPacket, clock_.ApproximateNow());
802 MaybeUpdateAckTimeout(kInstigateAck, kFirstDecimatedPacket);
803 CheckAckTimeout(ack_time);
804
805 RecordPacketReceipt(kFirstDecimatedPacket + 19, clock_.ApproximateNow());
806 MaybeUpdateAckTimeout(kInstigateAck, kFirstDecimatedPacket + 19);
807 CheckAckTimeout(ack_time);
808
809 // The 10th received packet causes an ack to be sent.
810 for (int i = 1; i < 9; ++i) {
811 RecordPacketReceipt(kFirstDecimatedPacket + i, clock_.ApproximateNow());
812 MaybeUpdateAckTimeout(kInstigateAck, kFirstDecimatedPacket + i);
813 }
814 CheckAckTimeout(clock_.ApproximateNow());
815
816 // The next packet received in order will cause an immediate ack, because it
817 // fills a hole.
818 RecordPacketReceipt(kFirstDecimatedPacket + 10, clock_.ApproximateNow());
819 MaybeUpdateAckTimeout(kInstigateAck, kFirstDecimatedPacket + 10);
820 CheckAckTimeout(clock_.ApproximateNow());
821}
822
823} // namespace
824} // namespace test
825} // namespace quic