predictors: Update the resource_prefetch_predictor db tool.

tools/resource_prefetch_predictor/prefetch_predictor_tool.py

 #!/usr/bin/python
 # Copyright 2016 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.
 
 """Inspection of the prefetch predictor database.
 
 On Android, the database can be extracted using:
 adb pull \
   '/data/user/0/$package_name/app_chrome/Default/Network Action Predictor'
   predictor_db
 """
 
 import argparse
-import operator
 import sqlite3
 
-from resource_prefetch_predictor_pb2 import ResourceData
+from resource_prefetch_predictor_pb2 import (PrefetchData, ResourceData)
 
 
 class Entry(object):
   """Represents an entry in the predictor database."""
   def __init__(
-      self, main_page_url, resource_url, proto_buffer):
-    self.main_page_url = main_page_url
-    self.resource_url = resource_url
-    self.proto = ResourceData()
-    self.proto.ParseFromString(proto_buffer)
-    self.confidence = float(self.proto.number_of_hits / (
-        self.proto.number_of_hits + self.proto.number_of_misses))
-    self.score = self._Score()
+      self, primary_key, proto_buffer):
+    self.primary_key = primary_key
+    self.prefetch_data = PrefetchData()
+    self.prefetch_data.ParseFromString(proto_buffer)
 
-  def _Score(self):
+  @classmethod
+  def _ComputeResourceScore(cls, resource):

[pasko, 2016/10/07 13:55:25]

Please mention the type of |resource| in the docstring here and in functions
below that have |resource| as paramater.

[Benoit L, 2016/10/07 14:03:10]

Done.

     """Mirrors ResourcePrefetchPredictorTables::ComputeResourceScore."""
     priority_multiplier = 1
     type_multiplier = 1
 
-    if self.proto.priority == ResourceData.REQUEST_PRIORITY_HIGHEST:
+    if resource.priority == ResourceData.REQUEST_PRIORITY_HIGHEST:
       priority_multiplier = 3
-    elif self.proto.priority == ResourceData.REQUEST_PRIORITY_MEDIUM:
+    elif resource.priority == ResourceData.REQUEST_PRIORITY_MEDIUM:
       priority_multiplier = 2
 
-    if self.proto.resource_type in (ResourceData.RESOURCE_TYPE_STYLESHEET,
-                                    ResourceData.RESOURCE_TYPE_SCRIPT):
+    if resource.resource_type in (ResourceData.RESOURCE_TYPE_STYLESHEET,
+                                  ResourceData.RESOURCE_TYPE_SCRIPT):
       type_multiplier = 3
-    elif self.proto.resource_type == ResourceData.RESOURCE_TYPE_FONT_RESOURCE:
+    elif resource.resource_type == ResourceData.RESOURCE_TYPE_FONT_RESOURCE:
       type_multiplier = 2
 
-      return (100 * (priority_multiplier * 100 + type_multiplier * 10)
-              - self.proto.average_position)
+    return (100 * (priority_multiplier * 100 + type_multiplier * 10)
+            - resource.average_position)
 
   @classmethod
   def FromRow(cls, row):
     """Builds an entry from a database row."""
     return Entry(*row)
 
-  def __str__(self):
-    return 'score: %s\nmain_page_url: %s\nconfidence: %f"\n%s' % (
-        self.score, self.main_page_url, self.confidence, self.proto)
+  @classmethod
+  def _PrettyPrintResource(cls, resource):
+      print 'score: %d' % cls._ComputeResourceScore(resource)
+      print resource

[pasko, 2016/10/07 13:55:25]

is the default python pretty-print looking good here? Perhaps pretty-print
manually? if you think that the default pretty-print is OK, please show it to
me, I am curious.

[Benoit L, 2016/10/07 14:03:10]

Actually, protocol buffer are already pretty when using print, but I want to add
the score here (in the same style as the rest of the proto fields).


Example:

score: 12951
resource_url:
"http://s1.lemde.fr/medias/web/e669e9d9f3321b41fd54ccb1bad21cc3/js/lmd/module/retina.js"
resource_type: RESOURCE_TYPE_SCRIPT
number_of_hits: 3
consecutive_misses: 0
average_position: 49.0
priority: REQUEST_PRIORITY_LOWEST
has_validators: true
always_revalidate: false

 
-
-def FilterAndSort(entries, domain):
-  """Filters and sorts the entries to be prefetched for a given domain.
-
-  Uses the default thresholds defined in resource_prefetch_common.cc.
-  """
-  result = filter(
-      lambda x: ((domain is None or x.main_page_url == domain)
-                 and x.confidence > .7
-                 and x.proto.number_of_hits >= 2), entries)
-  return sorted(result, key=operator.attrgetter('score'), reverse=True)
+  def PrettyPrintCandidates(self):
+    """Prints the candidates for prefetch."""
+    print 'primary_key: %s' % self.prefetch_data.primary_key
+    for resource in self.prefetch_data.resources:
+      confidence = resource.number_of_hits / (
+          resource.number_of_hits + resource.number_of_misses)

[pasko, 2016/10/07 13:55:25]

perhaps need to explicitly ask for a floating point result?

[Benoit L, 2016/10/07 14:03:10]

/facepalm
Thanks!

Done.

+      if resource.number_of_hits < 2 or confidence < .7:
+        continue
+      self._PrettyPrintResource(resource)
 
 
 def DatabaseStats(filename, domain):
   connection = sqlite3.connect(filename)
   c = connection.cursor()
-  query = ('SELECT main_page_url, resource_url, proto '
-           'FROM resource_prefetch_predictor_host')
+  query = ('SELECT key, proto FROM resource_prefetch_predictor_host')
   entries = [Entry.FromRow(row) for row in c.execute(query)]
-  prefetched = FilterAndSort(entries, domain)
-  for x in prefetched:
-    print x
+  for x in entries:
+    if domain is None or x.primary_key == domain:
+      x.PrettyPrintCandidates()
 
 
 def main():
   parser = argparse.ArgumentParser()
   parser.add_argument('-f', dest='database_filename', required=True,
                       help='Path to the database')
   parser.add_argument('-d', dest='domain', default=None, help='Domain')
   args = parser.parse_args()
   DatabaseStats(args.database_filename, args.domain)
 
 
 if __name__ == '__main__':
   main()