Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(343)

Unified Diff: net/quic/congestion_control/general_loss_algorithm.cc

Issue 2193073003: Move shared files in net/quic/ into net/quic/core/ (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: io_thread_unittest.cc Created 4 years, 5 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
Index: net/quic/congestion_control/general_loss_algorithm.cc
diff --git a/net/quic/congestion_control/general_loss_algorithm.cc b/net/quic/congestion_control/general_loss_algorithm.cc
deleted file mode 100644
index 9dfc7ce9cfcf70be06a4aeb8a34fc67fcf2de071..0000000000000000000000000000000000000000
--- a/net/quic/congestion_control/general_loss_algorithm.cc
+++ /dev/null
@@ -1,144 +0,0 @@
-// Copyright 2015 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "net/quic/congestion_control/general_loss_algorithm.h"
-
-#include "net/quic/congestion_control/rtt_stats.h"
-#include "net/quic/quic_bug_tracker.h"
-#include "net/quic/quic_flags.h"
-#include "net/quic/quic_protocol.h"
-
-namespace net {
-
-namespace {
-
-// The minimum delay before a packet will be considered lost,
-// regardless of SRTT. Half of the minimum TLP, since the loss algorithm only
-// triggers when a nack has been receieved for the packet.
-static const size_t kMinLossDelayMs = 5;
-
-// Default fraction of an RTT the algorithm waits before determining a packet is
-// lost due to early retransmission by time based loss detection.
-static const int kDefaultLossDelayShift = 2;
-// Default fraction of an RTT when doing adaptive loss detection.
-static const int kDefaultAdaptiveLossDelayShift = 4;
-
-} // namespace
-
-GeneralLossAlgorithm::GeneralLossAlgorithm()
- : loss_type_(kNack),
- loss_detection_timeout_(QuicTime::Zero()),
- largest_sent_on_spurious_retransmit_(0),
- reordering_shift_(kDefaultLossDelayShift) {}
-
-GeneralLossAlgorithm::GeneralLossAlgorithm(LossDetectionType loss_type)
- : loss_type_(loss_type),
- loss_detection_timeout_(QuicTime::Zero()),
- largest_sent_on_spurious_retransmit_(0),
- reordering_shift_(loss_type == kAdaptiveTime
- ? kDefaultAdaptiveLossDelayShift
- : kDefaultLossDelayShift) {}
-
-LossDetectionType GeneralLossAlgorithm::GetLossDetectionType() const {
- return loss_type_;
-}
-
-void GeneralLossAlgorithm::SetLossDetectionType(LossDetectionType loss_type) {
- loss_type_ = loss_type;
- if (loss_type_ == kAdaptiveTime) {
- reordering_shift_ = kDefaultAdaptiveLossDelayShift;
- }
-}
-
-// Uses nack counts to decide when packets are lost.
-void GeneralLossAlgorithm::DetectLosses(
- const QuicUnackedPacketMap& unacked_packets,
- QuicTime time,
- const RttStats& rtt_stats,
- QuicPacketNumber largest_newly_acked,
- SendAlgorithmInterface::CongestionVector* packets_lost) {
- QuicPacketNumber largest_observed = unacked_packets.largest_observed();
- if (FLAGS_quic_loss_recovery_use_largest_acked) {
- largest_observed = largest_newly_acked;
- }
- loss_detection_timeout_ = QuicTime::Zero();
- QuicTime::Delta max_rtt =
- std::max(rtt_stats.previous_srtt(), rtt_stats.latest_rtt());
- QuicTime::Delta loss_delay =
- std::max(QuicTime::Delta::FromMilliseconds(kMinLossDelayMs),
- max_rtt + (max_rtt >> reordering_shift_));
- QuicPacketNumber packet_number = unacked_packets.GetLeastUnacked();
- for (QuicUnackedPacketMap::const_iterator it = unacked_packets.begin();
- it != unacked_packets.end() && packet_number <= largest_observed;
- ++it, ++packet_number) {
- if (!it->in_flight) {
- continue;
- }
-
- if (loss_type_ == kNack) {
- // FACK based loss detection.
- if (largest_observed - packet_number >=
- kNumberOfNacksBeforeRetransmission) {
- packets_lost->push_back(std::make_pair(packet_number, it->bytes_sent));
- continue;
- }
- }
-
- // Only early retransmit(RFC5827) when the last packet gets acked and
- // there are retransmittable packets in flight.
- // This also implements a timer-protected variant of FACK.
- if ((!it->retransmittable_frames.empty() &&
- unacked_packets.largest_sent_packet() == largest_observed) ||
- (loss_type_ == kTime || loss_type_ == kAdaptiveTime)) {
- QuicTime when_lost = it->sent_time + loss_delay;
- if (time < when_lost) {
- loss_detection_timeout_ = when_lost;
- break;
- }
- packets_lost->push_back(std::make_pair(packet_number, it->bytes_sent));
- continue;
- }
-
- // NACK-based loss detection allows for a max reordering window of 1 RTT.
- if (it->sent_time + rtt_stats.smoothed_rtt() <
- unacked_packets.GetTransmissionInfo(largest_observed).sent_time) {
- packets_lost->push_back(std::make_pair(packet_number, it->bytes_sent));
- continue;
- }
- }
-}
-
-QuicTime GeneralLossAlgorithm::GetLossTimeout() const {
- return loss_detection_timeout_;
-}
-
-void GeneralLossAlgorithm::SpuriousRetransmitDetected(
- const QuicUnackedPacketMap& unacked_packets,
- QuicTime time,
- const RttStats& rtt_stats,
- QuicPacketNumber spurious_retransmission) {
- if (loss_type_ != kAdaptiveTime || reordering_shift_ == 0) {
- return;
- }
- if (spurious_retransmission <= largest_sent_on_spurious_retransmit_) {
- return;
- }
- largest_sent_on_spurious_retransmit_ = unacked_packets.largest_sent_packet();
- // Calculate the extra time needed so this wouldn't have been declared lost.
- // Extra time needed is based on how long it's been since the spurious
- // retransmission was sent, because the SRTT and latest RTT may have changed.
- QuicTime::Delta extra_time_needed =
- time -
- unacked_packets.GetTransmissionInfo(spurious_retransmission).sent_time;
- // Increase the reordering fraction until enough time would be allowed.
- QuicTime::Delta max_rtt =
- std::max(rtt_stats.previous_srtt(), rtt_stats.latest_rtt());
- QuicTime::Delta proposed_extra_time(QuicTime::Delta::Zero());
- do {
- proposed_extra_time = max_rtt >> reordering_shift_;
- --reordering_shift_;
- } while (proposed_extra_time < extra_time_needed && reordering_shift_ > 0);
-}
-
-} // namespace net
« no previous file with comments | « net/quic/congestion_control/general_loss_algorithm.h ('k') | net/quic/congestion_control/general_loss_algorithm_test.cc » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698