predictors: Add prefetching hit/miss histograms.

chrome/browser/predictors/resource_prefetch_predictor.cc

 // Copyright 2014 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 "chrome/browser/predictors/resource_prefetch_predictor.h"
 
 #include <map>
 #include <set>
 #include <utility>
 
@@ skipping 102 matching lines @@
     visit_count_ = url_row.visit_count();
   return true;
 }
 
 void GetUrlVisitCountTask::DoneRunOnMainThread() {
   callback_.Run(visit_count_, *summary_);
 }
 
 GetUrlVisitCountTask::~GetUrlVisitCountTask() {}
 
+void ReportPrefetchAccuracy(
+    const ResourcePrefetcher::PrefetcherStats& stats,
+    const std::vector<ResourcePrefetchPredictor::URLRequestSummary>&
+        summaries) {
+  if (stats.requests_stats.empty())
+    return;
+
+  std::set<GURL> urls;
+  for (const auto& summary : summaries)
+    urls.insert(summary.resource_url);
+
+  int cached_misses_count = 0;
+  int not_cached_misses_count = 0;
+  int cached_hits_count = 0;
+  int not_cached_hits_count = 0;
+  int64_t misses_bytes = 0;
+  int64_t hits_bytes = 0;
+
+  for (const auto& request_stats : stats.requests_stats) {
+    bool hit = urls.find(request_stats.resource_url) != urls.end();
+    bool cached = request_stats.was_cached;
+    size_t bytes = request_stats.total_received_bytes;
+
+    cached_hits_count += cached && hit;
+    cached_misses_count += cached && !hit;
+    not_cached_hits_count += !cached && hit;
+    not_cached_misses_count += !cached && !hit;
+    misses_bytes += !hit * bytes;
+    hits_bytes += hit * bytes;
+  }
+
+  UMA_HISTOGRAM_COUNTS_100(
+      internal::kResourcePrefetchPredictorPrefetchMissesCountCached,
+      cached_misses_count);
+  UMA_HISTOGRAM_COUNTS_100(
+      internal::kResourcePrefetchPredictorPrefetchMissesCountNotCached,
+      not_cached_misses_count);
+  UMA_HISTOGRAM_COUNTS_100(
+      internal::kResourcePrefetchPredictorPrefetchHitsCountCached,
+      cached_hits_count);
+  UMA_HISTOGRAM_COUNTS_100(
+      internal::kResourcePrefetchPredictorPrefetchHitsCountNotCached,
+      not_cached_hits_count);
+  UMA_HISTOGRAM_COUNTS_10000(
+      internal::kResourcePrefetchPredictorPrefetchHitsSize, hits_bytes / 1024);

[Ilya Sherman, 2017/02/15 00:07:41]

This goes up to about 10MB, right?  Is that enough range for this histogram?

[Benoit L, 2017/02/15 09:55:34]

I think so, yes. The amount of actual data fetched should be in the 100s of KB
range.

+  UMA_HISTOGRAM_COUNTS_10000(
+      internal::kResourcePrefetchPredictorPrefetchMissesSize,
+      misses_bytes / 1024);
+}
+
 void ReportPredictionAccuracy(
     const std::vector<GURL>& predicted_urls,
     const ResourcePrefetchPredictor::PageRequestSummary& summary) {
   DCHECK(!predicted_urls.empty());
 
   if (predicted_urls.empty() || summary.subresource_requests.empty())
     return;
 
   std::set<GURL> predicted_urls_set(predicted_urls.begin(),
                                     predicted_urls.end());
@@ skipping 409 matching lines @@
   if (!prefetch_manager_.get())  // Not enabled.
     return;
 
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&ResourcePrefetcherManager::MaybeRemovePrefetch,
                  prefetch_manager_, url));
 }
 
 void ResourcePrefetchPredictor::OnPrefetchingFinished(
-    const GURL& main_frame_url) {
+    const GURL& main_frame_url,
+    std::unique_ptr<ResourcePrefetcher::PrefetcherStats> stats) {
   if (observer_)
     observer_->OnPrefetchingFinished(main_frame_url);
+
+  prefetcher_stats_.insert(std::make_pair(main_frame_url, std::move(stats)));
 }
 
 bool ResourcePrefetchPredictor::IsUrlPrefetchable(const GURL& main_frame_url) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (initialization_state_ != INITIALIZED)
     return false;
 
   return GetPrefetchData(main_frame_url, nullptr);
 }
 
@@ skipping 10 matching lines @@
 }
 
 void ResourcePrefetchPredictor::OnMainFrameRequest(
     const URLRequestSummary& request) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK_EQ(INITIALIZED, initialization_state_);
 
   const GURL& main_frame_url = request.navigation_id.main_frame_url;
   StartPrefetching(main_frame_url, PrefetchOrigin::NAVIGATION);
 
-  // Cleanup older navigations.
   CleanupAbandonedNavigations(request.navigation_id);
 
   // New empty navigation entry.
   inflight_navigations_.insert(
       std::make_pair(request.navigation_id,
                      base::MakeUnique<PageRequestSummary>(main_frame_url)));
 }
 
 void ResourcePrefetchPredictor::OnMainFrameResponse(
     const URLRequestSummary& response) {
@@ skipping 54 matching lines @@
 
   NavigationMap::iterator nav_it =
       inflight_navigations_.find(nav_id_without_timing_info);
   if (nav_it == inflight_navigations_.end())
     return;
 
   // Remove the navigation from the inflight navigations.
   std::unique_ptr<PageRequestSummary> summary = std::move(nav_it->second);
   inflight_navigations_.erase(nav_it);
 
+  const GURL& main_frame_url = nav_id_without_timing_info.main_frame_url;
   std::vector<GURL> predicted_urls;
-  bool has_data = GetPrefetchData(nav_id_without_timing_info.main_frame_url,
-                                  &predicted_urls);
+  bool has_data = GetPrefetchData(main_frame_url, &predicted_urls);
   if (has_data)
     ReportPredictionAccuracy(predicted_urls, *summary);
 
+  auto it = prefetcher_stats_.find(main_frame_url);
+  if (it != prefetcher_stats_.end()) {
+    const std::vector<URLRequestSummary>& summaries =
+        summary->subresource_requests;
+    ReportPrefetchAccuracy(*it->second, summaries);
+    prefetcher_stats_.erase(it);
+  }
+
   // Kick off history lookup to determine if we should record the URL.
   history::HistoryService* history_service =
       HistoryServiceFactory::GetForProfile(profile_,
                                            ServiceAccessType::EXPLICIT_ACCESS);
   DCHECK(history_service);
   history_service->ScheduleDBTask(
       std::unique_ptr<history::HistoryDBTask>(new GetUrlVisitCountTask(
           std::move(summary),
           base::Bind(&ResourcePrefetchPredictor::OnVisitCountLookup,
                      AsWeakPtr()))),
@@ skipping 109 matching lines @@
     }
   }
 
   for (auto it = inflight_prefetches_.begin();
        it != inflight_prefetches_.end();) {
     if (time_now - it->second > max_navigation_age)
       it = inflight_prefetches_.erase(it);
     else
       ++it;
   }
+
+  // Remove old prefetches that haven't been claimed.
+  for (auto stats_it = prefetcher_stats_.begin();
+       stats_it != prefetcher_stats_.end();) {
+    if (time_now - stats_it->second->start_time > max_navigation_age) {
+      // No requests -> everything is a miss.
+      ReportPrefetchAccuracy(*stats_it->second,
+                             std::vector<URLRequestSummary>());
+      stats_it = prefetcher_stats_.erase(stats_it);
+    } else {
+      ++stats_it;
+    }
+  }
 }
 
 void ResourcePrefetchPredictor::DeleteAllUrls() {
   inflight_navigations_.clear();
   url_table_cache_->clear();
   host_table_cache_->clear();
   url_redirect_table_cache_->clear();
   host_redirect_table_cache_->clear();
 
   BrowserThread::PostTask(BrowserThread::DB, FROM_HERE,
@@ skipping 459 matching lines @@
 TestObserver::~TestObserver() {
   predictor_->SetObserverForTesting(nullptr);
 }
 
 TestObserver::TestObserver(ResourcePrefetchPredictor* predictor)
     : predictor_(predictor) {
   predictor_->SetObserverForTesting(this);
 }
 
 }  // namespace predictors