Adding more histograms to ResourcePrefetchPredictor.

chrome/browser/predictors/resource_prefetch_predictor.cc

 // Copyright (c) 2012 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>
 
 #include "base/command_line.h"
 #include "base/metrics/histogram.h"
 #include "base/stl_util.h"
+#include "base/string_number_conversions.h"
+#include "base/stringprintf.h"
 #include "base/time.h"
 #include "chrome/browser/history/history.h"
 #include "chrome/browser/history/history_notifications.h"
 #include "chrome/browser/history/history_service_factory.h"
 #include "chrome/browser/history/in_memory_database.h"
 #include "chrome/browser/history/url_database.h"
 #include "chrome/browser/predictors/predictor_database.h"
 #include "chrome/browser/predictors/predictor_database_factory.h"
 #include "chrome/browser/prerender/prerender_field_trial.h"
 #include "chrome/browser/profiles/profile.h"
@@ skipping 13 matching lines @@
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_context_getter.h"
 
 using content::BrowserThread;
 
 namespace {
 
 // Don't store subresources whose Urls are longer than this.
 size_t kMaxSubresourceUrlLengthBytes = 1000;
 
-// For reporting histograms about navigation status.
-enum NavigationStatus {
-  NAVIGATION_STATUS_COMPLETE = 0,
-  NAVIGATION_STATUS_COMPLETE_ABANDONED = 1,
-  NAVIGATION_STATUS_ABANDONED = 2,
-  NAVIGATION_STATUS_COUNT = 3
-};
-
 // For reporting whether a subresource is handled or not, and for what reasons.
 enum ResourceStatus {
   RESOURCE_STATUS_HANDLED = 0,
   RESOURCE_STATUS_NOT_HTTP_PAGE = 1,
   RESOURCE_STATUS_NOT_HTTP_RESOURCE = 2,
   RESOURCE_STATUS_UNSUPPORTED_MIME_TYPE = 4,
   RESOURCE_STATUS_NOT_GET = 8,
   RESOURCE_STATUS_URL_TOO_LONG = 16,
   RESOURCE_STATUS_NOT_CACHEABLE = 32,
   RESOURCE_STATUS_HEADERS_MISSING = 64,
   RESOURCE_STATUS_MAX = 128,
 };
 
+// For reporting various interesting events that occur during the loading of a
+// single main frame.
+enum NavigationEvent {
+  NAVIGATION_EVENT_REQUEST_STARTED = 0,
+  NAVIGATION_EVENT_REQUEST_REDIRECTED = 1,
+  NAVIGATION_EVENT_REQUEST_REDIRECTED_EMPTY_URL = 2,
+  NAVIGATION_EVENT_REQUEST_EXPIRED = 3,
+  NAVIGATION_EVENT_RESPONSE_STARTED = 4,
+  NAVIGATION_EVENT_ONLOAD = 5,
+  NAVIGATION_EVENT_ONLOAD_EMPTY_URL = 6,
+  NAVIGATION_EVENT_ONLOAD_UNTRACKED_URL = 7,
+  NAVIGATION_EVENT_ONLOAD_TRACKED_URL = 8,
+  NAVIGATION_EVENT_SHOULD_TRACK_URL = 9,
+  NAVIGATION_EVENT_SHOULD_NOT_TRACK_URL = 10,
+  NAVIGATION_EVENT_URL_TABLE_FULL = 11,
+  NAVIGATION_EVENT_HAVE_PREDICTIONS_FOR_URL = 12,
+  NAVIGATION_EVENT_NO_PREDICTIONS_FOR_URL = 13,
+  NAVIGATION_EVENT_COUNT = 14,
+};
+
 }  // namespace
 
 namespace predictors {
 
 ResourcePrefetchPredictor::Config::Config()
     : max_navigation_lifetime_seconds(60),
       max_urls_to_track(500),
       min_url_visit_count(3),
       max_resources_per_entry(50),
-      max_consecutive_misses(3),
-      num_resources_assumed_prefetched(25) {
+      max_consecutive_misses(3) {
 }
 
 ResourcePrefetchPredictor::URLRequestSummary::URLRequestSummary()
     : resource_type(ResourceType::LAST_TYPE),
       was_cached(false) {
 }
 
 ResourcePrefetchPredictor::URLRequestSummary::URLRequestSummary(
     const URLRequestSummary& other)
         : navigation_id(other.navigation_id),
@@ skipping 62 matching lines @@
   DCHECK_EQ(initialization_state_, INITIALIZING);
   DCHECK(url_table_cache_.empty());
   DCHECK(inflight_navigations_.empty());
 
   // Copy the data to local caches.
   for (UrlTableRowVector::iterator it = url_rows->begin();
        it != url_rows->end(); ++it) {
     url_table_cache_[it->main_frame_url].rows.push_back(*it);
   }
 
+  UMA_HISTOGRAM_COUNTS("ResourcePrefetchPredictor.UrlTableMainFrameUrlCount",
+                       url_table_cache_.size());
+
   // Score and sort the database caches.
   // TODO(shishir): The following would be much more efficient if we used
   // pointers.
   for (UrlTableCacheMap::iterator it = url_table_cache_.begin();
        it != url_table_cache_.end(); ++it) {
     std::sort(it->second.rows.begin(),
               it->second.rows.end(),
               ResourcePrefetchPredictorTables::UrlTableRowSorter());
   }
 
@@ skipping 152 matching lines @@
 
   CHECK_EQ(response.resource_type, ResourceType::MAIN_FRAME);
   OnMainFrameRedirect(response);
 }
 
 void ResourcePrefetchPredictor::OnMainFrameRequest(
     const URLRequestSummary& request) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK_EQ(INITIALIZED, initialization_state_);
 
+  UMA_HISTOGRAM_ENUMERATION("ResourcePrefetchPredictor.NavigationEvent",
+                            NAVIGATION_EVENT_REQUEST_STARTED,
+                            NAVIGATION_EVENT_COUNT);
+
   // Cleanup older navigations.
   CleanupAbandonedNavigations(request.navigation_id);
 
   // New empty navigation entry.
   inflight_navigations_.insert(std::make_pair(
       request.navigation_id, std::vector<URLRequestSummary>()));
 }
 
 void ResourcePrefetchPredictor::OnMainFrameResponse(
     const URLRequestSummary& response) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
+  UMA_HISTOGRAM_ENUMERATION("ResourcePrefetchPredictor.NavigationEvent",
+                            NAVIGATION_EVENT_RESPONSE_STARTED,
+                            NAVIGATION_EVENT_COUNT);
+
   // TODO(shishir): The prefreshing will be stopped here.
 }
 
 void ResourcePrefetchPredictor::OnMainFrameRedirect(
     const URLRequestSummary& response) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
+  UMA_HISTOGRAM_ENUMERATION("ResourcePrefetchPredictor.NavigationEvent",
+                            NAVIGATION_EVENT_REQUEST_REDIRECTED,
+                            NAVIGATION_EVENT_COUNT);
+
   // Remove the older navigation.
   inflight_navigations_.erase(response.navigation_id);
 
   // A redirect will not lead to another OnMainFrameRequest call, so record the
   // redirect url as a new navigation.
 
   // The redirect url may be empty if the url was invalid.
-  if (response.redirect_url.is_empty())
+  if (response.redirect_url.is_empty()) {
+    UMA_HISTOGRAM_ENUMERATION("ResourcePrefetchPredictor.NavigationEvent",
+                              NAVIGATION_EVENT_REQUEST_REDIRECTED_EMPTY_URL,
+                              NAVIGATION_EVENT_COUNT);
     return;
+  }
 
   NavigationID navigation_id(response.navigation_id);
   navigation_id.main_frame_url = response.redirect_url;
   inflight_navigations_.insert(std::make_pair(
       navigation_id, std::vector<URLRequestSummary>()));
 }
 
 void ResourcePrefetchPredictor::OnSubresourceResponse(
     const URLRequestSummary& response) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
@@ skipping 27 matching lines @@
     const NavigationID& navigation_id) {
   static const base::TimeDelta max_navigation_age =
       base::TimeDelta::FromSeconds(config_.max_navigation_lifetime_seconds);
 
   base::TimeTicks time_now = base::TimeTicks::Now();
   for (NavigationMap::iterator it = inflight_navigations_.begin();
        it != inflight_navigations_.end();) {
     if (it->first.IsSameRenderer(navigation_id) ||
         (time_now - it->first.creation_time > max_navigation_age)) {
       inflight_navigations_.erase(it++);
-      UMA_HISTOGRAM_ENUMERATION("ResourcePrefetchPredictor.NavigationStatus",
-                                NAVIGATION_STATUS_ABANDONED,
-                                NAVIGATION_STATUS_COUNT);
+      UMA_HISTOGRAM_ENUMERATION("ResourcePrefetchPredictor.NavigationEvent",
+                                NAVIGATION_EVENT_REQUEST_EXPIRED,
+                                NAVIGATION_EVENT_COUNT);
     } else {
       ++it;
     }
   }
 }
 
 void ResourcePrefetchPredictor::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   switch (type) {
     case content::NOTIFICATION_LOAD_COMPLETED_MAIN_FRAME: {
+      UMA_HISTOGRAM_ENUMERATION("ResourcePrefetchPredictor.NavigationEvent",
+                                NAVIGATION_EVENT_ONLOAD,
+                                NAVIGATION_EVENT_COUNT);
       const content::WebContents* web_contents =
           content::Source<content::WebContents>(source).ptr();
       NavigationID navigation_id(*web_contents);
       // WebContents can return an empty URL if the navigation entry
       // corresponding to the navigation has not been created yet.
-      if (!navigation_id.main_frame_url.is_empty())
+      if (navigation_id.main_frame_url.is_empty()) {
+        UMA_HISTOGRAM_ENUMERATION("ResourcePrefetchPredictor.NavigationEvent",
+                                  NAVIGATION_EVENT_ONLOAD_EMPTY_URL,
+                                  NAVIGATION_EVENT_COUNT);
+
+      } else {
         OnNavigationComplete(navigation_id);
+      }
       break;
     }
 
     case content::NOTIFICATION_LOAD_FROM_MEMORY_CACHE: {
       const content::LoadFromMemoryCacheDetails* load_details =
           content::Details<content::LoadFromMemoryCacheDetails>(details).ptr();
       const content::WebContents* web_contents =
           content::Source<content::NavigationController>(
               source).ptr()->GetWebContents();
 
@@ skipping 47 matching lines @@
          it != url_table_cache_.end();) {
       history::URLRow url_row;
       if (url_db->GetRowForURL(it->first, &url_row) == 0) {
         urls_to_delete.push_back(it->first);
         url_table_cache_.erase(it++);
       } else {
         it->second.last_visit = url_row.last_visit();
         ++it;
       }
     }
-    if (!urls_to_delete.empty())
+
+    if (!urls_to_delete.empty()) {
+      UMA_HISTOGRAM_COUNTS(
+          "ResourcePrefetchPredictor.UrlTableMainFrameUrlsDeletedNotInHistory",
+          urls_to_delete.size());
+      UMA_HISTOGRAM_PERCENTAGE(
+          "ResourcePrefetchPredictor."
+              "UrlTableMainFrameUrlsDeletedNotInHistoryPercent",
+          urls_to_delete.size() * 100.0 / url_table_cache_.size());
+
       BrowserThread::PostTask(BrowserThread::DB, FROM_HERE,
           base::Bind(&ResourcePrefetchPredictorTables::DeleteRowsForUrls,
                      tables_,
                      urls_to_delete));
+    }
   }
 
   notification_registrar_.Add(this,
                               content::NOTIFICATION_LOAD_FROM_MEMORY_CACHE,
                               content::NotificationService::AllSources());
   notification_registrar_.Add(this,
                               content::NOTIFICATION_LOAD_COMPLETED_MAIN_FRAME,
                               content::NotificationService::AllSources());
   notification_registrar_.Add(this,
                               chrome::NOTIFICATION_HISTORY_URLS_DELETED,
@@ skipping 10 matching lines @@
     return true;
 
   HistoryService* history_service = HistoryServiceFactory::GetForProfile(
       profile_, Profile::EXPLICIT_ACCESS);
   DCHECK(history_service);
   history::URLDatabase* url_db = history_service->InMemoryDatabase();
   if (!url_db)
     return false;
 
   history::URLRow url_row;
-  return url_db->GetRowForURL(url, &url_row) != 0 &&
-      url_row.visit_count() >= config_.min_url_visit_count;
+  int visit_count = 0;
+  if (url_db->GetRowForURL(url, &url_row) != 0)
+    visit_count = url_row.visit_count();
+
+  UMA_HISTOGRAM_COUNTS("ResourcePrefetchPredictor.HistoryVisitCountForUrl",
+                       visit_count);
+
+  return visit_count >= config_.min_url_visit_count;
 }
 
 void ResourcePrefetchPredictor::OnNavigationComplete(
     const NavigationID& navigation_id) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (inflight_navigations_.find(navigation_id) ==
       inflight_navigations_.end()) {
-    UMA_HISTOGRAM_ENUMERATION("ResourcePrefetchPredictor.NavigationStatus",
-                              NAVIGATION_STATUS_COMPLETE_ABANDONED,
-                              NAVIGATION_STATUS_COUNT);
+    UMA_HISTOGRAM_ENUMERATION("ResourcePrefetchPredictor.NavigationEvent",
+                              NAVIGATION_EVENT_ONLOAD_UNTRACKED_URL,
+                              NAVIGATION_EVENT_COUNT);
     return;
   }
 
-  UMA_HISTOGRAM_ENUMERATION("ResourcePrefetchPredictor.NavigationStatus",
-                            NAVIGATION_STATUS_COMPLETE,
-                            NAVIGATION_STATUS_COUNT);
+  UMA_HISTOGRAM_ENUMERATION("ResourcePrefetchPredictor.NavigationEvent",
+                            NAVIGATION_EVENT_ONLOAD_TRACKED_URL,
+                            NAVIGATION_EVENT_COUNT);
 
   // Report any stats.
   MaybeReportAccuracyStats(navigation_id);
 
   // Update the URL table.
   const GURL& main_frame_url = navigation_id.main_frame_url;
-  if (ShouldTrackUrl(main_frame_url))
+  if (ShouldTrackUrl(main_frame_url)) {
+    UMA_HISTOGRAM_ENUMERATION("ResourcePrefetchPredictor.NavigationEvent",
+                              NAVIGATION_EVENT_SHOULD_TRACK_URL,
+                              NAVIGATION_EVENT_COUNT);
     LearnUrlNavigation(main_frame_url, inflight_navigations_[navigation_id]);
+  } else {
+    UMA_HISTOGRAM_ENUMERATION("ResourcePrefetchPredictor.NavigationEvent",
+                              NAVIGATION_EVENT_SHOULD_NOT_TRACK_URL,
+                              NAVIGATION_EVENT_COUNT);
+  }
 
   // Remove the navigation.
   inflight_navigations_.erase(navigation_id);
 }
 
 void ResourcePrefetchPredictor::LearnUrlNavigation(
     const GURL& main_frame_url,
     const std::vector<URLRequestSummary>& new_resources) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
@@ skipping 100 matching lines @@
       base::Bind(&ResourcePrefetchPredictorTables::UpdateRowsForUrl,
                  tables_,
                  main_frame_url,
                  rows));
 }
 
 void ResourcePrefetchPredictor::RemoveAnEntryFromUrlDB() {
   if (url_table_cache_.empty())
     return;
 
+  UMA_HISTOGRAM_ENUMERATION("ResourcePrefetchPredictor.NavigationEvent",
+                            NAVIGATION_EVENT_URL_TABLE_FULL,
+                            NAVIGATION_EVENT_COUNT);
+
   // TODO(shishir): Maybe use a heap to do this more efficiently.
   base::Time oldest_time;
   GURL url_to_erase;
   for (UrlTableCacheMap::iterator it = url_table_cache_.begin();
        it != url_table_cache_.end(); ++it) {
     if (url_to_erase.is_empty() || it->second.last_visit < oldest_time) {
       url_to_erase = it->first;
       oldest_time = it->second.last_visit;
     }
   }
   url_table_cache_.erase(url_to_erase);
 
   std::vector<GURL> urls_to_delete(1, url_to_erase);
   BrowserThread::PostTask(BrowserThread::DB, FROM_HERE,
       base::Bind(&ResourcePrefetchPredictorTables::DeleteRowsForUrls,
                  tables_,
                  urls_to_delete));
 }
 
 void ResourcePrefetchPredictor::MaybeReportAccuracyStats(
     const NavigationID& navigation_id) const {
   const GURL& main_frame_url = navigation_id.main_frame_url;
   DCHECK(inflight_navigations_.find(navigation_id) !=
          inflight_navigations_.end());
 
   bool have_predictions_for_url =
       url_table_cache_.find(main_frame_url) != url_table_cache_.end();
-  UMA_HISTOGRAM_BOOLEAN("ResourcePrefetchPredictor.HavePredictionsForUrl",
-                        have_predictions_for_url);
-  if (!have_predictions_for_url)
+  if (have_predictions_for_url) {
+    UMA_HISTOGRAM_ENUMERATION("ResourcePrefetchPredictor.NavigationEvent",
+                              NAVIGATION_EVENT_HAVE_PREDICTIONS_FOR_URL,
+                              NAVIGATION_EVENT_COUNT);
+  } else {
+    UMA_HISTOGRAM_ENUMERATION("ResourcePrefetchPredictor.NavigationEvent",
+                              NAVIGATION_EVENT_NO_PREDICTIONS_FOR_URL,
+                              NAVIGATION_EVENT_COUNT);
     return;
+  }
 
   const std::vector<URLRequestSummary>& actual =
       inflight_navigations_.find(navigation_id)->second;
   const UrlTableRowVector& predicted =
       url_table_cache_.find(main_frame_url)->second.rows;
 
   std::map<GURL, bool> actual_resources;
+  int total_resources_fetched_from_network = 0;
   for (std::vector<URLRequestSummary>::const_iterator it = actual.begin();
        it != actual.end(); ++it) {
     actual_resources[it->resource_url] = it->was_cached;
+    if (!it->was_cached)
+      ++total_resources_fetched_from_network;
   }
 
+  // Measure accuracy at 25, and 50 predicted resources.
   int prefetch_cached = 0, prefetch_network = 0, prefetch_missed = 0;
-  int num_assumed_prefetched = std::min(
-      static_cast<int>(predicted.size()),
-      config_.num_resources_assumed_prefetched);
+  int num_assumed_prefetched = std::min(static_cast<int>(predicted.size()),
+                                        50);
   for (int i = 0; i < num_assumed_prefetched; ++i) {
     const UrlTableRow& row = predicted[i];
-    if (actual_resources.find(row.resource_url) == actual_resources.end()) {
+    std::map<GURL, bool>::const_iterator it = actual_resources.find(
+        row.resource_url);
+    if (it == actual_resources.end()) {
       ++prefetch_missed;
-    } else if (actual_resources[row.resource_url]) {
+    } else if (it->second) {
       ++prefetch_cached;
     } else {
       ++prefetch_network;
     }
+
+    if ((num_assumed_prefetched < 25 && i == num_assumed_prefetched - 1) ||
+        i == 24) {
+      UMA_HISTOGRAM_COUNTS(

[dominich, 2012/08/31 20:40:45]

if you define a macro that takes 25 or 50 as a parameter you should be able to
simplify all of this. See the prerender_histograms for how to call histogram
macros with various parameters.

[Shishir, 2012/08/31 21:03:31]

Wrote macros not to use the static initializer which also works. It is a bit
more inefficient, so if you think I should writes ones that take the number as a
param instead, let me know.

+          "ResourcePrefetchPredictor.PredictedPrefetchCount_25",
+          num_assumed_prefetched);
+      UMA_HISTOGRAM_COUNTS(
+          "ResourcePrefetchPredictor.PredictedPrefetchMisses_Count_25",
+          prefetch_missed);
+      UMA_HISTOGRAM_COUNTS(
+          "ResourcePrefetchPredictor.PredictedPrefetchFromCache_Count_25",
+          prefetch_cached);
+      UMA_HISTOGRAM_COUNTS(
+          "ResourcePrefetchPredictor.PredictedPrefetchFromNetwork_Count_25",
+          prefetch_network);
+      UMA_HISTOGRAM_PERCENTAGE(
+          "ResourcePrefetchPredictor.PredictedPrefetchMisses_"
+          "PercentOfTotalPrefetched_25",
+          prefetch_missed * 100.0 / (i + 1));
+      UMA_HISTOGRAM_PERCENTAGE(
+          "ResourcePrefetchPredictor.PredictedPrefetchFromCache_"
+          "PercentOfTotalPrefetched_25",
+          prefetch_cached * 100.0 / (i + 1));
+      UMA_HISTOGRAM_PERCENTAGE(
+          "ResourcePrefetchPredictor.PredictedPrefetchFromNetwork_"
+          "PercentOfTotalPrefetched_25",
+          prefetch_network * 100.0 / (i + 1));
+
+      // Measure the ratio of total number of resources prefetched from network
+      // vs the total number of resources fetched by the page from the network.
+      UMA_HISTOGRAM_PERCENTAGE(
+          "ResourcePrefetchPredictor."
+          "PredictedPrefetchFromNetworkPercentOfTotalFromNetwork_25",
+          prefetch_network * 100.0 / total_resources_fetched_from_network);
+    }
   }
 
+  UMA_HISTOGRAM_COUNTS(
+      "ResourcePrefetchPredictor.PredictedPrefetchCount_50",
+      num_assumed_prefetched);
+  UMA_HISTOGRAM_COUNTS(
+      "ResourcePrefetchPredictor.PredictedPrefetchMisses_Count_50",
+      prefetch_missed);
+  UMA_HISTOGRAM_COUNTS(
+      "ResourcePrefetchPredictor.PredictedPrefetchFromCache_Count_50",
+      prefetch_cached);
+  UMA_HISTOGRAM_COUNTS(
+      "ResourcePrefetchPredictor.PredictedPrefetchFromNetwork_Count_50",
+      prefetch_network);
   UMA_HISTOGRAM_PERCENTAGE(
-      "ResourcePrefetchPredictor.PredictedPrefetchMisses",
+      "ResourcePrefetchPredictor.PredictedPrefetchMisses_"
+      "PercentOfTotalPrefetched_50",
       prefetch_missed * 100.0 / num_assumed_prefetched);
   UMA_HISTOGRAM_PERCENTAGE(
-      "ResourcePrefetchPredictor.PredictedPrefetchFromCache",
+      "ResourcePrefetchPredictor.PredictedPrefetchFromCache_"
+      "PercentOfTotalPrefetched_50",
       prefetch_cached * 100.0 / num_assumed_prefetched);
   UMA_HISTOGRAM_PERCENTAGE(
-      "ResourcePrefetchPredictor.PredictedPrefetchFromNetwork",
+      "ResourcePrefetchPredictor.PredictedPrefetchFromNetwork_"
+      "PercentOfTotalPrefetched_50",
       prefetch_network * 100.0 / num_assumed_prefetched);
+
+  // Measure the ratio of total number of resources prefetched from network vs
+  // the total number of resources fetched by the page from the network.
+  UMA_HISTOGRAM_PERCENTAGE(
+      "ResourcePrefetchPredictor."
+      "PredictedPrefetchFromNetworkPercentOfTotalFromNetwork_50",
+      prefetch_network * 100.0 / total_resources_fetched_from_network);
 }
 
 void ResourcePrefetchPredictor::DeleteAllUrls() {
   inflight_navigations_.clear();
   url_table_cache_.clear();
 
   BrowserThread::PostTask(BrowserThread::DB, FROM_HERE,
       base::Bind(&ResourcePrefetchPredictorTables::DeleteAllRows, tables_));
 }
 
@@ skipping 16 matching lines @@
                    tables_,
                    urls_to_delete));
 }
 
 void ResourcePrefetchPredictor::SetTablesForTesting(
     scoped_refptr<ResourcePrefetchPredictorTables> tables) {
   tables_ = tables;
 }
 
 }  // namespace predictors