gfe-relnote: (n/a) Pluming work for loss detection tuning using go/smartchoices. No behavior change, not protected.
This adds 4 'broadcast' points to a quic session: SetLossDetectionTuner, OnMinRttAvailable, OnConfigNegotiated and OnConnectionClosed. Currently nothing is done at these points. The next CL will implement a loss detection tuner and use it from uStreamer.
PiperOrigin-RevId: 298729689
Change-Id: I90cabde07e9d4a1ab82b66cd4d416005db5ee7ec
diff --git a/quic/core/congestion_control/general_loss_algorithm.h b/quic/core/congestion_control/general_loss_algorithm.h
index 50c5c05..9f7175f 100644
--- a/quic/core/congestion_control/general_loss_algorithm.h
+++ b/quic/core/congestion_control/general_loss_algorithm.h
@@ -47,6 +47,21 @@
QuicPacketNumber packet_number,
QuicPacketNumber previous_largest_acked) override;
+ void OnConfigNegotiated() override {
+ DCHECK(false)
+ << "Unexpected call to GeneralLossAlgorithm::OnConfigNegotiated";
+ }
+
+ void OnMinRttAvailable() override {
+ DCHECK(false)
+ << "Unexpected call to GeneralLossAlgorithm::OnMinRttAvailable";
+ }
+
+ void OnConnectionClosed() override {
+ DCHECK(false)
+ << "Unexpected call to GeneralLossAlgorithm::OnConnectionClosed";
+ }
+
void SetPacketNumberSpace(PacketNumberSpace packet_number_space);
int reordering_shift() const { return reordering_shift_; }
@@ -55,6 +70,10 @@
reordering_shift_ = reordering_shift;
}
+ void set_reordering_threshold(QuicPacketCount reordering_threshold) {
+ reordering_threshold_ = reordering_threshold;
+ }
+
bool use_adaptive_reordering_threshold() const {
return use_adaptive_reordering_threshold_;
}
diff --git a/quic/core/congestion_control/loss_detection_interface.h b/quic/core/congestion_control/loss_detection_interface.h
index 601f2f7..729cbad 100644
--- a/quic/core/congestion_control/loss_detection_interface.h
+++ b/quic/core/congestion_control/loss_detection_interface.h
@@ -39,6 +39,12 @@
QuicTime ack_receive_time,
QuicPacketNumber packet_number,
QuicPacketNumber previous_largest_acked) = 0;
+
+ virtual void OnConfigNegotiated() = 0;
+
+ virtual void OnMinRttAvailable() = 0;
+
+ virtual void OnConnectionClosed() = 0;
};
} // namespace quic
diff --git a/quic/core/congestion_control/uber_loss_algorithm.cc b/quic/core/congestion_control/uber_loss_algorithm.cc
index ad8ef3f..30d213f 100644
--- a/quic/core/congestion_control/uber_loss_algorithm.cc
+++ b/quic/core/congestion_control/uber_loss_algorithm.cc
@@ -66,12 +66,28 @@
packet_number, previous_largest_acked);
}
+void UberLossAlgorithm::SetLossDetectionTuner(
+ std::unique_ptr<LossDetectionTunerInterface> /*tuner*/) {}
+
+void UberLossAlgorithm::OnConfigNegotiated() {}
+
+void UberLossAlgorithm::OnMinRttAvailable() {}
+
+void UberLossAlgorithm::OnConnectionClosed() {}
+
void UberLossAlgorithm::SetReorderingShift(int reordering_shift) {
for (int8_t i = INITIAL_DATA; i < NUM_PACKET_NUMBER_SPACES; ++i) {
general_loss_algorithms_[i].set_reordering_shift(reordering_shift);
}
}
+void UberLossAlgorithm::SetReorderingThreshold(
+ QuicPacketCount reordering_threshold) {
+ for (int8_t i = INITIAL_DATA; i < NUM_PACKET_NUMBER_SPACES; ++i) {
+ general_loss_algorithms_[i].set_reordering_threshold(reordering_threshold);
+ }
+}
+
void UberLossAlgorithm::EnableAdaptiveReorderingThreshold() {
for (int8_t i = INITIAL_DATA; i < NUM_PACKET_NUMBER_SPACES; ++i) {
general_loss_algorithms_[i].set_use_adaptive_reordering_threshold(true);
diff --git a/quic/core/congestion_control/uber_loss_algorithm.h b/quic/core/congestion_control/uber_loss_algorithm.h
index 4248553..397dda7 100644
--- a/quic/core/congestion_control/uber_loss_algorithm.h
+++ b/quic/core/congestion_control/uber_loss_algorithm.h
@@ -6,6 +6,7 @@
#define QUICHE_QUIC_CORE_CONGESTION_CONTROL_UBER_LOSS_ALGORITHM_H_
#include "net/third_party/quiche/src/quic/core/congestion_control/general_loss_algorithm.h"
+#include "net/third_party/quiche/src/common/platform/api/quiche_optional.h"
namespace quic {
@@ -15,6 +16,28 @@
} // namespace test
+struct QUIC_EXPORT_PRIVATE LossDetectionParameters {
+ // See GeneralLossAlgorithm for the meaning of reordering_(shift|threshold).
+ quiche::QuicheOptional<int> reordering_shift;
+ quiche::QuicheOptional<QuicPacketCount> reordering_threshold;
+};
+
+class QUIC_EXPORT_PRIVATE LossDetectionTunerInterface {
+ public:
+ virtual ~LossDetectionTunerInterface() {}
+
+ // Start the tuning by choosing parameters and saving them into |*params|.
+ // Called near the start of a QUIC session, see the .cc file for exactly
+ // where.
+ virtual bool Start(LossDetectionParameters* params) = 0;
+
+ // Finish tuning. The tuner is expected to use the actual loss detection
+ // performance(for its definition of performance) to improve the parameter
+ // selection for future QUIC sessions.
+ // Called when a QUIC session closes.
+ virtual void Finish(const LossDetectionParameters& params) = 0;
+};
+
// This class comprises multiple loss algorithms, each per packet number space.
class QUIC_EXPORT_PRIVATE UberLossAlgorithm : public LossDetectionInterface {
public:
@@ -41,9 +64,18 @@
QuicPacketNumber packet_number,
QuicPacketNumber previous_largest_acked) override;
+ void SetLossDetectionTuner(
+ std::unique_ptr<LossDetectionTunerInterface> tuner);
+ void OnConfigNegotiated() override;
+ void OnMinRttAvailable() override;
+ void OnConnectionClosed() override;
+
// Sets reordering_shift for all packet number spaces.
void SetReorderingShift(int reordering_shift);
+ // Sets reordering_threshold for all packet number spaces.
+ void SetReorderingThreshold(QuicPacketCount reordering_threshold);
+
// Enable adaptive reordering threshold of all packet number spaces.
void EnableAdaptiveReorderingThreshold();
diff --git a/quic/core/quic_connection.cc b/quic/core/quic_connection.cc
index f9c4da7..8fc858c 100644
--- a/quic/core/quic_connection.cc
+++ b/quic/core/quic_connection.cc
@@ -523,6 +523,15 @@
sent_packet_manager_.AdjustNetworkParameters(params);
}
+void QuicConnection::SetLossDetectionTuner(
+ std::unique_ptr<LossDetectionTunerInterface> tuner) {
+ sent_packet_manager_.SetLossDetectionTuner(std::move(tuner));
+}
+
+void QuicConnection::OnConfigNegotiated() {
+ sent_packet_manager_.OnConfigNegotiated();
+}
+
QuicBandwidth QuicConnection::MaxPacingRate() const {
return sent_packet_manager_.MaxPacingRate();
}
@@ -3000,6 +3009,7 @@
FlushPackets();
connected_ = false;
DCHECK(visitor_ != nullptr);
+ sent_packet_manager_.OnConnectionClosed();
visitor_->OnConnectionClosed(frame, source);
if (debug_visitor_ != nullptr) {
debug_visitor_->OnConnectionClosed(frame, source);
diff --git a/quic/core/quic_connection.h b/quic/core/quic_connection.h
index b4c2f44..cbfa29f 100644
--- a/quic/core/quic_connection.h
+++ b/quic/core/quic_connection.h
@@ -388,6 +388,12 @@
QuicTime::Delta rtt,
bool allow_cwnd_to_decrease);
+ // Install a loss detection tuner. Must be called before OnConfigNegotiated.
+ void SetLossDetectionTuner(
+ std::unique_ptr<LossDetectionTunerInterface> tuner);
+ // Called by the session when session->is_configured() becomes true.
+ void OnConfigNegotiated();
+
// Returns the max pacing rate for the connection.
virtual QuicBandwidth MaxPacingRate() const;
diff --git a/quic/core/quic_sent_packet_manager.cc b/quic/core/quic_sent_packet_manager.cc
index c8fd641..eb59a8e 100644
--- a/quic/core/quic_sent_packet_manager.cc
+++ b/quic/core/quic_sent_packet_manager.cc
@@ -339,6 +339,19 @@
}
}
+void QuicSentPacketManager::SetLossDetectionTuner(
+ std::unique_ptr<LossDetectionTunerInterface> tuner) {
+ uber_loss_algorithm_.SetLossDetectionTuner(std::move(tuner));
+}
+
+void QuicSentPacketManager::OnConfigNegotiated() {
+ loss_algorithm_->OnConfigNegotiated();
+}
+
+void QuicSentPacketManager::OnConnectionClosed() {
+ loss_algorithm_->OnConnectionClosed();
+}
+
void QuicSentPacketManager::SetHandshakeConfirmed() {
if (!handshake_finished_) {
handshake_finished_ = true;
@@ -951,8 +964,13 @@
}
QuicTime::Delta send_delta = ack_receive_time - transmission_info.sent_time;
+ const bool min_rtt_available = !rtt_stats_.min_rtt().IsZero();
rtt_stats_.UpdateRtt(send_delta, ack_delay_time, ack_receive_time);
+ if (!min_rtt_available && !rtt_stats_.min_rtt().IsZero()) {
+ loss_algorithm_->OnMinRttAvailable();
+ }
+
return true;
}
diff --git a/quic/core/quic_sent_packet_manager.h b/quic/core/quic_sent_packet_manager.h
index fa0634b..951cdb0 100644
--- a/quic/core/quic_sent_packet_manager.h
+++ b/quic/core/quic_sent_packet_manager.h
@@ -151,6 +151,11 @@
void AdjustNetworkParameters(
const SendAlgorithmInterface::NetworkParams& params);
+ void SetLossDetectionTuner(
+ std::unique_ptr<LossDetectionTunerInterface> tuner);
+ void OnConfigNegotiated();
+ void OnConnectionClosed();
+
// Retransmits the oldest pending packet there is still a tail loss probe
// pending. Invoked after OnRetransmissionTimeout.
bool MaybeRetransmitTailLossProbe();
@@ -538,7 +543,7 @@
QuicPacketCount initial_congestion_window_;
RttStats rtt_stats_;
std::unique_ptr<SendAlgorithmInterface> send_algorithm_;
- // Not owned. Always points to |general_loss_algorithm_| outside of tests.
+ // Not owned. Always points to |uber_loss_algorithm_| outside of tests.
LossDetectionInterface* loss_algorithm_;
UberLossAlgorithm uber_loss_algorithm_;
diff --git a/quic/core/quic_session.cc b/quic/core/quic_session.cc
index 4df126f..de61dfe 100644
--- a/quic/core/quic_session.cc
+++ b/quic/core/quic_session.cc
@@ -1136,6 +1136,7 @@
config_.ReceivedInitialSessionFlowControlWindowBytes());
}
is_configured_ = true;
+ connection()->OnConfigNegotiated();
// Inform stream ID manager so that it can reevaluate any deferred
// STREAMS_BLOCKED or MAX_STREAMS frames against the config and either send
diff --git a/quic/core/quic_session.h b/quic/core/quic_session.h
index 7f8e251..65d2226 100644
--- a/quic/core/quic_session.h
+++ b/quic/core/quic_session.h
@@ -624,6 +624,11 @@
bool MaybeSetStreamPriority(QuicStreamId stream_id,
const spdy::SpdyStreamPrecedence& precedence);
+ void SetLossDetectionTuner(
+ std::unique_ptr<LossDetectionTunerInterface> tuner) {
+ connection()->SetLossDetectionTuner(std::move(tuner));
+ }
+
private:
friend class test::QuicSessionPeer;
diff --git a/quic/test_tools/quic_test_utils.h b/quic/test_tools/quic_test_utils.h
index b20f90e..6b8403c 100644
--- a/quic/test_tools/quic_test_utils.h
+++ b/quic/test_tools/quic_test_utils.h
@@ -997,6 +997,10 @@
QuicTime,
QuicPacketNumber,
QuicPacketNumber));
+
+ MOCK_METHOD0(OnConfigNegotiated, void());
+ MOCK_METHOD0(OnMinRttAvailable, void());
+ MOCK_METHOD0(OnConnectionClosed, void());
};
class MockAckListener : public QuicAckListenerInterface {
