Record RTT prediction accuracy when using average algorithms

net/nqe/network_quality_estimator.cc

 // 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/nqe/network_quality_estimator.h"
 
 #include <algorithm>
 #include <cmath>
 #include <limits>
 #include <utility>
 #include <vector>
 
 #include "base/bind_helpers.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/metrics/histogram_base.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/metrics/sparse_histogram.h"
 #include "base/rand_util.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
+#include "base/strings/string_piece.h"
 #include "base/strings/stringprintf.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/default_tick_clock.h"
 #include "base/trace_event/trace_event.h"
 #include "build/build_config.h"
 #include "net/base/load_flags.h"
 #include "net/base/load_timing_info.h"
 #include "net/base/network_interfaces.h"
 #include "net/base/trace_constants.h"
 #include "net/base/url_util.h"
@@ skipping 114 matching lines @@
   // kBitsPerMetric.
   static const int32_t kLargestValuePossible = (1 << kBitsPerMetric) - 1;
   if (metric > kLargestValuePossible) {
     // Fit |metric| in kBitsPerMetric by clamping it down.
     metric = kLargestValuePossible;
   }
   DCHECK_EQ(0, metric >> kBitsPerMetric) << metric;
   return metric;
 }
 
-void RecordRTTAccuracy(const char* prefix,
+void RecordRTTAccuracy(base::StringPiece prefix,
                        int32_t metric,
                        base::TimeDelta measuring_duration,
                        base::TimeDelta observed_rtt) {
   const std::string histogram_name =
-      base::StringPrintf("%s.EstimatedObservedDiff.%s.%d.%s", prefix,
+      base::StringPrintf("%s.EstimatedObservedDiff.%s.%d.%s", prefix.data(),
                          metric >= 0 ? "Positive" : "Negative",
                          static_cast<int32_t>(measuring_duration.InSeconds()),
                          GetHistogramSuffixObservedRTT(observed_rtt));
 
   base::HistogramBase* histogram = base::Histogram::FactoryGet(
       histogram_name, 1, 10 * 1000 /* 10 seconds */, 50 /* Number of buckets */,
       base::HistogramBase::kUmaTargetedHistogramFlag);
   histogram->Add(std::abs(metric));
 }
 
@@ skipping 165 matching lines @@
       base::ThreadTaskRunnerHandle::Get(),
       nqe::internal::GetMinSocketWatcherNotificationInterval(variation_params),
       base::Bind(&NetworkQualityEstimator::OnUpdatedRTTAvailable,
                  base::Unretained(this)),
       tick_clock_.get()));
 
   // Record accuracy after a 15 second interval. The values used here must
   // remain in sync with the suffixes specified in
   // tools/metrics/histograms/histograms.xml.
   accuracy_recording_intervals_.push_back(base::TimeDelta::FromSeconds(15));
+
+  for (int i = 0; i < STATISTIC_LAST; ++i)
+    http_rtt_at_last_main_frame_[i] = nqe::internal::InvalidRTT();
 }
 
 void NetworkQualityEstimator::ObtainOperatingParams(
     const std::map<std::string, std::string>& variation_params) {
   DCHECK(thread_checker_.CalledOnValidThread());
   nqe::internal::ObtainDefaultObservations(variation_params,
                                            default_observations_);
   nqe::internal::ObtainEffectiveConnectionTypeModelParams(
       variation_params, connection_thresholds_);
   nqe::internal::ObtainTypicalNetworkQuality(typical_network_quality_);
@@ skipping 60 matching lines @@
   // request.
   // TODO(tbansal): Refactor this to a separate method.
   if (request.load_flags() & LOAD_MAIN_FRAME_DEPRECATED) {
     base::TimeTicks now = tick_clock_->NowTicks();
     last_main_frame_request_ = now;
 
     MaybeComputeEffectiveConnectionType();
     effective_connection_type_at_last_main_frame_ = effective_connection_type_;
     estimated_quality_at_last_main_frame_ = network_quality_;
 
+    // Record the HTTP at the last main frame for experimental statistics.
+    for (int i = 0; i < STATISTIC_LAST; ++i) {
+      http_rtt_at_last_main_frame_[i] = GetRTTEstimateInternal(
+          disallowed_observation_sources_for_http_, base::TimeTicks(),
+          static_cast<Statistic>(i), 50);
+    }
+
     // Post the tasks which will run in the future and record the estimation
     // accuracy based on the observations received between now and the time of
     // task execution. Posting the task at different intervals makes it
     // possible to measure the accuracy by comparing the estimate with the
     // observations received over intervals of varying durations.
     for (const base::TimeDelta& measuring_delay :
          GetAccuracyRecordingIntervals()) {
       base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
           FROM_HERE,
           base::Bind(&NetworkQualityEstimator::RecordAccuracyAfterMainFrame,
@@ skipping 70 matching lines @@
   // time. Returning here ensures that we do not take inaccurate readings.
   if (now - last_main_frame_request_ > 2 * measuring_duration)
     return;
 
   // Do not record accuracy if there was a connection change since the last main
   // frame request.
   if (last_main_frame_request_ <= last_connection_change_)
     return;
 
   base::TimeDelta recent_http_rtt;
+
+  // Record the HTTP prediction accuracy for experimental statistics.
+  for (int i = 0; i < STATISTIC_LAST; ++i) {
+    recent_http_rtt = GetRTTEstimateInternal(
+        disallowed_observation_sources_for_http_, last_main_frame_request_,
+        static_cast<Statistic>(i), 50);
+    if (recent_http_rtt != nqe::internal::InvalidRTT() &&
+        http_rtt_at_last_main_frame_[i] != nqe::internal::InvalidRTT()) {
+      int estimated_observed_diff_milliseconds =
+          http_rtt_at_last_main_frame_[i].InMilliseconds() -
+          recent_http_rtt.InMilliseconds();
+
+      std::string histogram_name =
+          base::StringPrintf("NQE.%s.Accuracy.HttpRTT", GetNameForStatistic(i));
+      RecordRTTAccuracy(histogram_name, estimated_observed_diff_milliseconds,
+                        measuring_duration, recent_http_rtt);
+    }
+  }
+
   if (!GetRecentHttpRTT(last_main_frame_request_, &recent_http_rtt))
     recent_http_rtt = nqe::internal::InvalidRTT();
 
   if (estimated_quality_at_last_main_frame_.http_rtt() !=
           nqe::internal::InvalidRTT() &&
       recent_http_rtt != nqe::internal::InvalidRTT()) {
     const int estimated_observed_diff_milliseconds =
         estimated_quality_at_last_main_frame_.http_rtt().InMilliseconds() -
         recent_http_rtt.InMilliseconds();
 
@@ skipping 315 matching lines @@
   current_network_id_ = GetCurrentNetworkID();
   RecordNetworkIDAvailability();
 
   MaybeQueryExternalEstimateProvider();
 
   // Read any cached estimates for the new network. If cached estimates are
   // unavailable, add the default estimates.
   if (!ReadCachedNetworkQualityEstimate())
     AddDefaultEstimates();
   estimated_quality_at_last_main_frame_ = nqe::internal::NetworkQuality();
+
+  for (int i = 0; i < STATISTIC_LAST; ++i)
+    http_rtt_at_last_main_frame_[i] = nqe::internal::InvalidRTT();
+
   throughput_analyzer_->OnConnectionTypeChanged();
   MaybeComputeEffectiveConnectionType();
 }
 
 void NetworkQualityEstimator::MaybeQueryExternalEstimateProvider() const {
   // Query the external estimate provider on certain connection types. Once the
   // updated estimates are available, OnUpdatedEstimateAvailable will be called
   // by |external_estimate_provider_| with updated estimates.
   if (external_estimate_provider_ &&
       current_network_id_.type != NetworkChangeNotifier::CONNECTION_NONE &&
@@ skipping 38 matching lines @@
   base::TimeDelta rtt;
   if (GetRecentHttpRTT(base::TimeTicks(), &rtt)) {
     // Add the 50th percentile value.
     base::HistogramBase* rtt_percentile =
         GetHistogram("RTT.Percentile50.", current_network_id_.type, 10 * 1000);
     rtt_percentile->Add(rtt.InMilliseconds());
 
     // Add the remaining percentile values.
     static const int kPercentiles[] = {0, 10, 90, 100};
     for (size_t i = 0; i < arraysize(kPercentiles); ++i) {
-      rtt = GetRTTEstimateInternal(disallowed_observation_sources_for_http_,
-                                   base::TimeTicks(), kPercentiles[i]);
+      rtt = GetRTTEstimateInternal(
+          disallowed_observation_sources_for_http_, base::TimeTicks(),
+          base::Optional<Statistic>(), kPercentiles[i]);
 
       rtt_percentile = GetHistogram(
           "RTT.Percentile" + base::IntToString(kPercentiles[i]) + ".",
           current_network_id_.type, 10 * 1000);  // 10 seconds
       rtt_percentile->Add(rtt.InMilliseconds());
     }
   }
 
   if (GetRecentTransportRTT(base::TimeTicks(), &rtt)) {
     // Add the 50th percentile value.
     base::HistogramBase* transport_rtt_percentile = GetHistogram(
         "TransportRTT.Percentile50.", current_network_id_.type, 10 * 1000);
     transport_rtt_percentile->Add(rtt.InMilliseconds());
 
     // Add the remaining percentile values.
     static const int kPercentiles[] = {0, 10, 90, 100};
     for (size_t i = 0; i < arraysize(kPercentiles); ++i) {
-      rtt =
-          GetRTTEstimateInternal(disallowed_observation_sources_for_transport_,
-                                 base::TimeTicks(), kPercentiles[i]);
+      rtt = GetRTTEstimateInternal(
+          disallowed_observation_sources_for_transport_, base::TimeTicks(),
+          base::Optional<Statistic>(), kPercentiles[i]);
 
       transport_rtt_percentile = GetHistogram(
           "TransportRTT.Percentile" + base::IntToString(kPercentiles[i]) + ".",
           current_network_id_.type, 10 * 1000);  // 10 seconds
       transport_rtt_percentile->Add(rtt.InMilliseconds());
     }
   }
 }
 
 void NetworkQualityEstimator::RecordNetworkIDAvailability() const {
@@ skipping 60 matching lines @@
   base::HistogramBase* effective_connection_type_histogram =
       base::Histogram::FactoryGet(
           std::string("NQE.MainFrame.EffectiveConnectionType.") +
               nqe::internal::GetNameForConnectionType(current_network_id_.type),
           0, EFFECTIVE_CONNECTION_TYPE_LAST,
           EFFECTIVE_CONNECTION_TYPE_LAST /* Number of buckets */,
           base::HistogramBase::kUmaTargetedHistogramFlag);
 
   effective_connection_type_histogram->Add(
       effective_connection_type_at_last_main_frame_);
+
+  // Record the HTTP RTT at the main frames for experimental statistics.
+  for (int i = 0; i < STATISTIC_LAST; ++i) {
+    if (http_rtt_at_last_main_frame_[i] != nqe::internal::InvalidRTT()) {
+      base::HistogramBase* rtt_histogram = base::Histogram::FactoryGet(
+          base::StringPrintf("NQE.%s.MainFrame.RTT", GetNameForStatistic(i)), 1,
+          10 * 1000, 50, base::HistogramBase::kUmaTargetedHistogramFlag);
+      rtt_histogram->Add(http_rtt_at_last_main_frame_[i].InMilliseconds());
+    }
+  }
 }
 
 void NetworkQualityEstimator::ComputeEffectiveConnectionType() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   UpdateSignalStrength();
 
   const base::TimeTicks now = tick_clock_->NowTicks();
 
   const EffectiveConnectionType past_type = effective_connection_type_;
@@ skipping 255 matching lines @@
     RTTAndThroughputEstimatesObserver* observer) {
   DCHECK(thread_checker_.CalledOnValidThread());
   rtt_and_throughput_estimates_observer_list_.RemoveObserver(observer);
 }
 
 bool NetworkQualityEstimator::GetRecentHttpRTT(
     const base::TimeTicks& start_time,
     base::TimeDelta* rtt) const {
   DCHECK(thread_checker_.CalledOnValidThread());
   *rtt = GetRTTEstimateInternal(disallowed_observation_sources_for_http_,
-                                start_time, 50);
+                                start_time, base::Optional<Statistic>(), 50);
   return (*rtt != nqe::internal::InvalidRTT());
 }
 
 bool NetworkQualityEstimator::GetRecentTransportRTT(
     const base::TimeTicks& start_time,
     base::TimeDelta* rtt) const {
   DCHECK(thread_checker_.CalledOnValidThread());
   *rtt = GetRTTEstimateInternal(disallowed_observation_sources_for_transport_,
-                                start_time, 50);
+                                start_time, base::Optional<Statistic>(), 50);
   return (*rtt != nqe::internal::InvalidRTT());
 }
 
 bool NetworkQualityEstimator::GetRecentDownlinkThroughputKbps(
     const base::TimeTicks& start_time,
     int32_t* kbps) const {
   DCHECK(thread_checker_.CalledOnValidThread());
   *kbps = GetDownlinkThroughputKbpsEstimateInternal(start_time, 50);
   return (*kbps != nqe::internal::kInvalidThroughput);
 }
 
 base::TimeDelta NetworkQualityEstimator::GetRTTEstimateInternal(
     const std::vector<NetworkQualityObservationSource>&
         disallowed_observation_sources,
-    const base::TimeTicks& start_time,
+    base::TimeTicks start_time,
+    const base::Optional<Statistic>& statistic,
     int percentile) const {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // RTT observations are sorted by duration from shortest to longest, thus
   // a higher percentile RTT will have a longer RTT than a lower percentile.
   base::TimeDelta rtt = nqe::internal::InvalidRTT();
-  if (!rtt_observations_.GetPercentile(start_time, signal_strength_dbm_, &rtt,
-                                       percentile,
-                                       disallowed_observation_sources)) {
-    return nqe::internal::InvalidRTT();
+
+  if (!statistic) {
+    // Use default statistic algorithm.
+    if (!rtt_observations_.GetPercentile(start_time, signal_strength_dbm_, &rtt,
+                                         percentile,
+                                         disallowed_observation_sources)) {
+      return nqe::internal::InvalidRTT();
+    }
+    return rtt;
   }
-  return rtt;
+
+  switch (statistic.value()) {
+    case STATISTIC_LAST:
+      NOTREACHED();
+      return nqe::internal::InvalidRTT();
+    case STATISTIC_WEIGHTED_AVERAGE:
+      if (!rtt_observations_.GetWeightedAverage(
+              start_time, signal_strength_dbm_, disallowed_observation_sources,
+              &rtt)) {
+        return nqe::internal::InvalidRTT();
+      }
+      return rtt;
+    case STATISTIC_UNWEIGHTED_AVERAGE:
+      if (!rtt_observations_.GetUnweightedAverage(
+              start_time, signal_strength_dbm_, disallowed_observation_sources,
+              &rtt)) {
+        return nqe::internal::InvalidRTT();
+      }
+      return rtt;
+  }
+  NOTREACHED();
+  return nqe::internal::InvalidRTT();
 }
 
 int32_t NetworkQualityEstimator::GetDownlinkThroughputKbpsEstimateInternal(
     const base::TimeTicks& start_time,
     int percentile) const {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // Throughput observations are sorted by kbps from slowest to fastest,
   // thus a higher percentile throughput will be faster than a lower one.
   int32_t kbps = nqe::internal::kInvalidThroughput;
@@ skipping 388 matching lines @@
         base::TimeTicks::Now(), INT32_MIN,
         NETWORK_QUALITY_OBSERVATION_SOURCE_HTTP_CACHED_ESTIMATE);
     downstream_throughput_kbps_observations_.AddObservation(
         throughput_observation);
     NotifyObserversOfThroughput(throughput_observation);
   }
 
   ComputeEffectiveConnectionType();
 }
 
+const char* NetworkQualityEstimator::GetNameForStatistic(int i) const {
+  Statistic statistic = static_cast<Statistic>(i);
+  switch (statistic) {
+    case STATISTIC_WEIGHTED_AVERAGE:
+      return "WeightedAverage";
+    case STATISTIC_UNWEIGHTED_AVERAGE:
+      return "UnweightedAverage";
+    case STATISTIC_LAST:
+      NOTREACHED();
+      return "";
+  }
+  NOTREACHED();
+  return "";
+}
+
 }  // namespace net