1 // Copyright 2014 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 "quiche/quic/core/congestion_control/rtt_stats.h"
6
7 #include <cstdlib> // std::abs
8
9 #include "quiche/quic/platform/api/quic_flag_utils.h"
10 #include "quiche/quic/platform/api/quic_flags.h"
11 #include "quiche/quic/platform/api/quic_logging.h"
12
13 namespace quic {
14
15 namespace {
16
17 const float kAlpha = 0.125f;
18 const float kOneMinusAlpha = (1 - kAlpha);
19 const float kBeta = 0.25f;
20 const float kOneMinusBeta = (1 - kBeta);
21
22 } // namespace
23
RttStats()24 RttStats::RttStats()
25 : latest_rtt_(QuicTime::Delta::Zero()),
26 min_rtt_(QuicTime::Delta::Zero()),
27 smoothed_rtt_(QuicTime::Delta::Zero()),
28 previous_srtt_(QuicTime::Delta::Zero()),
29 mean_deviation_(QuicTime::Delta::Zero()),
30 calculate_standard_deviation_(false),
31 initial_rtt_(QuicTime::Delta::FromMilliseconds(kInitialRttMs)),
32 last_update_time_(QuicTime::Zero()) {}
33
ExpireSmoothedMetrics()34 void RttStats::ExpireSmoothedMetrics() {
35 mean_deviation_ = std::max(
36 mean_deviation_, QuicTime::Delta::FromMicroseconds(std::abs(
37 (smoothed_rtt_ - latest_rtt_).ToMicroseconds())));
38 smoothed_rtt_ = std::max(smoothed_rtt_, latest_rtt_);
39 }
40
41 // Updates the RTT based on a new sample.
UpdateRtt(QuicTime::Delta send_delta,QuicTime::Delta ack_delay,QuicTime now)42 bool RttStats::UpdateRtt(QuicTime::Delta send_delta, QuicTime::Delta ack_delay,
43 QuicTime now) {
44 if (send_delta.IsInfinite() || send_delta <= QuicTime::Delta::Zero()) {
45 QUIC_LOG_FIRST_N(WARNING, 3)
46 << "Ignoring measured send_delta, because it's is "
47 << "either infinite, zero, or negative. send_delta = "
48 << send_delta.ToMicroseconds();
49 return false;
50 }
51
52 last_update_time_ = now;
53
54 // Update min_rtt_ first. min_rtt_ does not use an rtt_sample corrected for
55 // ack_delay but the raw observed send_delta, since poor clock granularity at
56 // the client may cause a high ack_delay to result in underestimation of the
57 // min_rtt_.
58 if (min_rtt_.IsZero() || min_rtt_ > send_delta) {
59 min_rtt_ = send_delta;
60 }
61
62 QuicTime::Delta rtt_sample(send_delta);
63 previous_srtt_ = smoothed_rtt_;
64 // Correct for ack_delay if information received from the peer results in a
65 // an RTT sample at least as large as min_rtt. Otherwise, only use the
66 // send_delta.
67 // TODO(fayang): consider to ignore rtt_sample if rtt_sample < ack_delay and
68 // ack_delay is relatively large.
69 if (rtt_sample > ack_delay) {
70 if (rtt_sample - min_rtt_ >= ack_delay) {
71 rtt_sample = rtt_sample - ack_delay;
72 } else {
73 QUIC_CODE_COUNT(quic_ack_delay_makes_rtt_sample_smaller_than_min_rtt);
74 }
75 } else {
76 QUIC_CODE_COUNT(quic_ack_delay_greater_than_rtt_sample);
77 }
78 latest_rtt_ = rtt_sample;
79 if (calculate_standard_deviation_) {
80 standard_deviation_calculator_.OnNewRttSample(rtt_sample, smoothed_rtt_);
81 }
82 // First time call.
83 if (smoothed_rtt_.IsZero()) {
84 smoothed_rtt_ = rtt_sample;
85 mean_deviation_ =
86 QuicTime::Delta::FromMicroseconds(rtt_sample.ToMicroseconds() / 2);
87 } else {
88 mean_deviation_ = QuicTime::Delta::FromMicroseconds(static_cast<int64_t>(
89 kOneMinusBeta * mean_deviation_.ToMicroseconds() +
90 kBeta * std::abs((smoothed_rtt_ - rtt_sample).ToMicroseconds())));
91 smoothed_rtt_ = kOneMinusAlpha * smoothed_rtt_ + kAlpha * rtt_sample;
92 QUIC_DVLOG(1) << " smoothed_rtt(us):" << smoothed_rtt_.ToMicroseconds()
93 << " mean_deviation(us):" << mean_deviation_.ToMicroseconds();
94 }
95 return true;
96 }
97
OnConnectionMigration()98 void RttStats::OnConnectionMigration() {
99 latest_rtt_ = QuicTime::Delta::Zero();
100 min_rtt_ = QuicTime::Delta::Zero();
101 smoothed_rtt_ = QuicTime::Delta::Zero();
102 mean_deviation_ = QuicTime::Delta::Zero();
103 initial_rtt_ = QuicTime::Delta::FromMilliseconds(kInitialRttMs);
104 }
105
GetStandardOrMeanDeviation() const106 QuicTime::Delta RttStats::GetStandardOrMeanDeviation() const {
107 QUICHE_DCHECK(calculate_standard_deviation_);
108 if (!standard_deviation_calculator_.has_valid_standard_deviation) {
109 return mean_deviation_;
110 }
111 return standard_deviation_calculator_.CalculateStandardDeviation();
112 }
113
OnNewRttSample(QuicTime::Delta rtt_sample,QuicTime::Delta smoothed_rtt)114 void RttStats::StandardDeviationCalculator::OnNewRttSample(
115 QuicTime::Delta rtt_sample, QuicTime::Delta smoothed_rtt) {
116 double new_value = rtt_sample.ToMicroseconds();
117 if (smoothed_rtt.IsZero()) {
118 return;
119 }
120 has_valid_standard_deviation = true;
121 const double delta = new_value - smoothed_rtt.ToMicroseconds();
122 m2 = kOneMinusBeta * m2 + kBeta * pow(delta, 2);
123 }
124
125 QuicTime::Delta
CalculateStandardDeviation() const126 RttStats::StandardDeviationCalculator::CalculateStandardDeviation() const {
127 QUICHE_DCHECK(has_valid_standard_deviation);
128 return QuicTime::Delta::FromMicroseconds(sqrt(m2));
129 }
130
CloneFrom(const RttStats & stats)131 void RttStats::CloneFrom(const RttStats& stats) {
132 latest_rtt_ = stats.latest_rtt_;
133 min_rtt_ = stats.min_rtt_;
134 smoothed_rtt_ = stats.smoothed_rtt_;
135 previous_srtt_ = stats.previous_srtt_;
136 mean_deviation_ = stats.mean_deviation_;
137 standard_deviation_calculator_ = stats.standard_deviation_calculator_;
138 calculate_standard_deviation_ = stats.calculate_standard_deviation_;
139 initial_rtt_ = stats.initial_rtt_;
140 last_update_time_ = stats.last_update_time_;
141 }
142
143 } // namespace quic
144