Enable QUIC's flow-label-based blackhole avoidance logic when the server receives the CFLS connection option from the client. Protected by quic_reloadable_flag_quic_allow_flow_label_blackhole_avoidance_on_server. PiperOrigin-RevId: 794640799
diff --git a/quiche/common/quiche_feature_flags_list.h b/quiche/common/quiche_feature_flags_list.h index 654676f..e066f54 100755 --- a/quiche/common/quiche_feature_flags_list.h +++ b/quiche/common/quiche_feature_flags_list.h
@@ -14,6 +14,7 @@ QUICHE_FLAG(bool, quiche_reloadable_flag_quic_add_stream_info_to_idle_close_detail, false, true, "If true, include stream information in idle timeout connection close detail.") QUICHE_FLAG(bool, quiche_reloadable_flag_quic_allow_client_enabled_2x_initial_cwnd, true, true, "Doubles the initial congestion window for QUIC connections when initiated by the client") QUICHE_FLAG(bool, quiche_reloadable_flag_quic_allow_client_enabled_bbr_v2, true, true, "If true, allow client to enable BBRv2 on server via connection option 'B2ON'.") +QUICHE_FLAG(bool, quiche_reloadable_flag_quic_allow_flow_label_blackhole_avoidance_on_server, false, false, "Change the flow label on the server side and attempt repathing to avoid blackhole.") QUICHE_FLAG(bool, quiche_reloadable_flag_quic_bbr2_extra_acked_window, false, true, "When true, the BBR4 copt sets the extra_acked window to 20 RTTs and BBR5 sets it to 40 RTTs.") QUICHE_FLAG(bool, quiche_reloadable_flag_quic_bbr2_probe_two_rounds, true, true, "When true, the BB2U copt causes BBR2 to wait two rounds with out draining the queue before exiting PROBE_UP and BB2S has the same effect in STARTUP.") QUICHE_FLAG(bool, quiche_reloadable_flag_quic_bbr2_simplify_inflight_hi, true, true, "When true, the BBHI copt causes QUIC BBRv2 to use a simpler algorithm for raising inflight_hi in PROBE_UP.")
diff --git a/quiche/quic/core/crypto/crypto_protocol.h b/quiche/quic/core/crypto/crypto_protocol.h index c8dd332..a23c64d 100644 --- a/quiche/quic/core/crypto/crypto_protocol.h +++ b/quiche/quic/core/crypto/crypto_protocol.h
@@ -535,9 +535,12 @@ DEFINE_STATIC_QUIC_TAG(PDE3); // 3 PTOs for path degradation. DEFINE_STATIC_QUIC_TAG(PDE5); // 5 PTOs for path degradation. DEFINE_STATIC_QUIC_TAG(MPR1); // Probe for multi-port path on RTO. +// TODO: b/433537286 - Remove this tag once the experiment is complete. +DEFINE_STATIC_QUIC_TAG(CFLS); // Enable flow-label-based blackhole avoidance on + // the server side when the client sends CFLS. -// Experiment for explicit connection close packet for silent idle timeout from -// server. +// Experiment for explicit connection close packet for silent idle timeout +// from server. DEFINE_STATIC_QUIC_TAG(ECCP); #undef DEFINE_STATIC_QUIC_TAG
diff --git a/quiche/quic/core/http/end_to_end_test.cc b/quiche/quic/core/http/end_to_end_test.cc index ac7c036..c92efe2 100644 --- a/quiche/quic/core/http/end_to_end_test.cc +++ b/quiche/quic/core/http/end_to_end_test.cc
@@ -8631,6 +8631,36 @@ EXPECT_EQ(GetClientConnection()->ecn_codepoint(), ECN_NOT_ECT); } +TEST_P(EndToEndTest, ChangeFlowLabelOnRTO) { + SetQuicReloadableFlag(quic_allow_flow_label_blackhole_avoidance_on_server, + true); + client_extra_copts_.push_back(kCFLS); + server_address_ = + QuicSocketAddress(QuicIpAddress::Loopback6(), server_address_.port()); + ASSERT_TRUE(Initialize()); + if (!version_.HasIetfQuicFrames()) { + return; + } + + // Block the client until the server changes its flow label on RTO. + EXPECT_TRUE(server_thread_->WaitUntil( + [&]() { + QuicConnection* server_connection = GetServerConnection(); + if (server_connection == nullptr) { + return false; + } + QuicConnectionStats server_stats = server_connection->GetStats(); + EXPECT_TRUE( + server_connection->enable_black_hole_avoidance_via_flow_label()); + EXPECT_TRUE(server_stats.num_flow_label_changes == 0 || + server_stats.pto_count > 0); + return server_connection->GetStats().num_flow_label_changes > 0; + }, + QuicTime::Delta::FromSeconds(5))); + + client_->Disconnect(); +} + } // namespace } // namespace test } // namespace quic
diff --git a/quiche/quic/core/quic_connection.cc b/quiche/quic/core/quic_connection.cc index f0b2be0..503252c 100644 --- a/quiche/quic/core/quic_connection.cc +++ b/quiche/quic/core/quic_connection.cc
@@ -625,6 +625,15 @@ } } + if (perspective_ == Perspective::IS_SERVER && version().HasIetfQuicFrames() && + config.HasClientSentConnectionOption(kCFLS, perspective_) && + GetQuicReloadableFlag( + quic_allow_flow_label_blackhole_avoidance_on_server)) { + QUIC_RELOADABLE_FLAG_COUNT( + quic_allow_flow_label_blackhole_avoidance_on_server); + EnableBlackholeAvoidanceViaFlowLabel(); + } + if (config.HasMinAckDelayDraft10ToSend()) { if (config.GetMinAckDelayDraft10ToSendMs() <= config.GetMaxAckDelayToSendMs()) { // MinAckDelay is valid.
diff --git a/quiche/quic/core/quic_connection_test.cc b/quiche/quic/core/quic_connection_test.cc index 3814725..7204be6 100644 --- a/quiche/quic/core/quic_connection_test.cc +++ b/quiche/quic/core/quic_connection_test.cc
@@ -10112,6 +10112,106 @@ EXPECT_TRUE(connection_.GetRetransmissionAlarm()->IsSet()); } +TEST_P(QuicConnectionTest, EnablingBlackHoleAvoidanceViaFlowLabel) { + QuicConfig config; + QuicTagVector connection_options; + connection_options.push_back(kCFLS); + config.SetConnectionOptionsToSend(connection_options); + EXPECT_CALL(*send_algorithm_, SetFromConfig(_, _)); + EXPECT_CALL(*send_algorithm_, EnableECT1()).WillOnce(Return(false)); + EXPECT_CALL(*send_algorithm_, EnableECT0()).WillOnce(Return(false)); + connection_.SetFromConfig(config); + EXPECT_FALSE(connection_.GetRetransmissionAlarm()->IsSet()); + EXPECT_EQ(0, connection_.outgoing_flow_label()); + connection_.EnableBlackholeAvoidanceViaFlowLabel(); + static_cast<test::MockRandom*>(helper_->GetRandomGenerator())->ChangeValue(); + const uint32_t flow_label = connection_.outgoing_flow_label(); + EXPECT_NE(0, flow_label); + + QuicStreamId stream_id = 2; + QuicPacketNumber last_packet; + SendStreamDataToPeer(stream_id, "foooooo", 0, NO_FIN, &last_packet); + SendStreamDataToPeer(stream_id, "foooooo", 7, NO_FIN, &last_packet); + EXPECT_EQ(QuicPacketNumber(2), last_packet); + EXPECT_TRUE(connection_.GetRetransmissionAlarm()->IsSet()); + + // Fire PTO and verify the flow label has changed. + EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(1); + connection_.GetRetransmissionAlarm()->Fire(); + EXPECT_NE(flow_label, connection_.outgoing_flow_label()); + EXPECT_EQ(1, connection_.GetStats().num_flow_label_changes); + + EXPECT_CALL(visitor_, OnForwardProgressMadeAfterFlowLabelChange()); + EXPECT_CALL(*send_algorithm_, OnCongestionEvent(_, _, _, _, _, _, _)); + QuicAckFrame frame = InitAckFrame(last_packet); + ProcessAckPacket(1, &frame); + EXPECT_EQ( + 1, connection_.GetStats().num_forward_progress_after_flow_label_change); +} + +TEST_P(QuicConnectionTest, ReceivingNewFlowLabelWithGapChangesFlowLabel) { + QuicConfig config; + QuicTagVector connection_options; + connection_options.push_back(kCFLS); + config.SetConnectionOptionsToSend(connection_options); + EXPECT_CALL(*send_algorithm_, SetFromConfig(_, _)); + EXPECT_CALL(*send_algorithm_, EnableECT1()).WillOnce(Return(false)); + EXPECT_CALL(*send_algorithm_, EnableECT0()).WillOnce(Return(false)); + connection_.SetFromConfig(config); + EXPECT_EQ(0, connection_.outgoing_flow_label()); + connection_.EnableBlackholeAvoidanceViaFlowLabel(); + static_cast<test::MockRandom*>(helper_->GetRandomGenerator())->ChangeValue(); + const uint32_t flow_label = connection_.outgoing_flow_label(); + EXPECT_NE(0, flow_label); + EXPECT_CALL(visitor_, OnStreamFrame(_)).Times(AnyNumber()); + + // Receive the first packet to initialize the flow label. + ProcessDataPacketAtLevel(1, !kHasStopWaiting, ENCRYPTION_INITIAL, 0); + EXPECT_EQ(flow_label, connection_.outgoing_flow_label()); + + // Receive the second packet with the same flow label + ProcessDataPacketAtLevel(2, !kHasStopWaiting, ENCRYPTION_INITIAL, flow_label); + EXPECT_EQ(flow_label, connection_.outgoing_flow_label()); + + // Receive a packet with gap and a new flow label and verify the outgoing + // flow label has changed. + static_cast<test::MockRandom*>(helper_->GetRandomGenerator())->ChangeValue(); + ProcessDataPacketAtLevel(4, !kHasStopWaiting, ENCRYPTION_INITIAL, + flow_label + 1); + EXPECT_NE(flow_label, connection_.outgoing_flow_label()); +} + +TEST_P(QuicConnectionTest, + ReceivingNewFlowLabelWithNoGapDoesNotChangeFlowLabel) { + QuicConfig config; + QuicTagVector connection_options; + connection_options.push_back(kCFLS); + config.SetConnectionOptionsToSend(connection_options); + EXPECT_CALL(*send_algorithm_, SetFromConfig(_, _)); + EXPECT_CALL(*send_algorithm_, EnableECT1()).WillOnce(Return(false)); + EXPECT_CALL(*send_algorithm_, EnableECT0()).WillOnce(Return(false)); + connection_.SetFromConfig(config); + EXPECT_EQ(0, connection_.outgoing_flow_label()); + connection_.EnableBlackholeAvoidanceViaFlowLabel(); + static_cast<test::MockRandom*>(helper_->GetRandomGenerator())->ChangeValue(); + const uint32_t flow_label = connection_.outgoing_flow_label(); + EXPECT_NE(0, flow_label); + EXPECT_CALL(visitor_, OnStreamFrame(_)).Times(AnyNumber()); + + // Receive the first packet to initialize the flow label. + ProcessDataPacketAtLevel(1, !kHasStopWaiting, ENCRYPTION_INITIAL, 0); + EXPECT_EQ(flow_label, connection_.outgoing_flow_label()); + + // Receive the second packet with the same flow label + ProcessDataPacketAtLevel(2, !kHasStopWaiting, ENCRYPTION_INITIAL, flow_label); + EXPECT_EQ(flow_label, connection_.outgoing_flow_label()); + + // Receive a packet with no gap and a new flow label and verify the outgoing + // flow label has not changed. + ProcessDataPacketAtLevel(3, !kHasStopWaiting, ENCRYPTION_INITIAL, flow_label); + EXPECT_EQ(flow_label, connection_.outgoing_flow_label()); +} + TEST_P(QuicConnectionTest, PtoChangesFlowLabel) { QuicConfig config; QuicTagVector connection_options;