Add script injection when replaying with callstats.py

tools/callstats.py

 #!/usr/bin/env python
 # Copyright 2016 the V8 project authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 '''
 Usage: runtime-call-stats.py [-h] <command> ...
 
 Optional arguments:
   -h, --help  show this help message and exit
 
@@ skipping 16 matching lines @@
 import tempfile
 
 import numpy
 import scipy
 import scipy.stats
 from math import sqrt
 
 
 # Run benchmarks.
 
-DEFAULT_SITES = [
-    # top websites (http://alexa.com/topsites): --------------------
-    "https://www.google.de/search?q=v8",
-    "https://www.youtube.com",
-    "https://www.facebook.com/shakira",
-    "http://www.baidu.com/s?wd=v8",
-    "http://www.yahoo.co.jp",
-    "http://www.amazon.com/s/?field-keywords=v8",
-    "http://hi.wikipedia.org/wiki/" \
-     "%E0%A4%AE%E0%A5%81%E0%A4%96%E0%A4%AA%E0%A5%83%E0%A4%B7%E0%A5%8D%E0%A4%A0",
-    "http://www.qq.com",
-    "http://www.twitter.com/taylorswift13",
-    "http://www.reddit.com",
-    "http://www.ebay.fr/sch/i.html?_nkw=v8",
-    "http://edition.cnn.com",
-    "http://world.taobao.com",
-    "http://www.instagram.com/archdigest",
-    "https://www.linkedin.com/pub/dir/?first=john&last=doe&search=search",
-    "http://www.msn.com/ar-ae",
-    "http://www.bing.com/search?q=v8+engine",
-    "http://www.pinterest.com/categories/popular",
-    "http://www.sina.com.cn",
-    "http://weibo.com",
-    "http://yandex.ru/search/?text=v8",
-    # framework driven decisions: -----------------------------------
-    # wikipedia content + angularjs
-    "http://www.wikiwand.com/en/hill",
-    # ember website
-    "http://meta.discourse.org",
-    # backbone js
-    "http://reddit.musicplayer.io",
-    # gwt application
-    "http://inbox.google.com",
-    # webgl / algorithmic case
-    "http://maps.google.co.jp/maps/search/restaurant+tokyo",
-    # whatever framework adwords uses
-    "https://adwords.google.com",
-]
-
-
 def print_command(cmd_args):
   def fix_for_printing(arg):
     m = re.match(r'^--([^=]+)=(.*)$', arg)
     if m and (' ' in m.group(2) or m.group(2).startswith('-')):
       arg = "--{}='{}'".format(m.group(1), m.group(2))
     elif ' ' in arg:
       arg = "'{}'".format(arg)
     return arg
   print " ".join(map(fix_for_printing, cmd_args))
 
 
-def start_replay_server(args):
+def start_replay_server(args, sites):
+  with tempfile.NamedTemporaryFile(prefix='callstats-inject-', suffix='.js',
+                                   mode='wt', delete=False) as f:
+    injection = f.name
+    generate_injection(f, sites)
   cmd_args = [
       args.replay_bin,
       "--port=4080",
       "--ssl_port=4443",
       "--no-dns_forwarding",
       "--use_closest_match",
       "--no-diff_unknown_requests",
+      "--inject_scripts=deterministic.js,{}".format(injection),
       args.replay_wpr,
   ]
   print "=" * 80
   print_command(cmd_args)
   with open(os.devnull, 'w') as null:
     server = subprocess.Popen(cmd_args, stdout=null, stderr=null)
   print "RUNNING REPLAY SERVER: %s with PID=%s" % (args.replay_bin, server.pid)
   print "=" * 80
-  return server
+  return {'process': server, 'injection': injection}
 
 
 def stop_replay_server(server):
-  print("SHUTTING DOWN REPLAY SERVER %s" % server.pid)
-  server.terminate()
+  print("SHUTTING DOWN REPLAY SERVER %s" % server['process'].pid)
+  server['process'].terminate()
+  os.remove(server['injection'])
+
+
+def generate_injection(f, sites):
+  print >> f, """\
+(function() {
+  function match(url, item) {
+    if ('regexp' in item) return url.match(item.regexp) !== null;
+    let url_wanted = item.url;
+    // Allow automatic redirections from http to https.
+    if (url_wanted.startsWith("http://") && url.startsWith("https://")) {
+      url_wanted = "https://" + url_wanted.substr(7);
+    }
+    return url.startsWith(url_wanted);
+  };
+
+  function onLoad(e) {
+    let url = e.target.URL;
+    for (let item of sites) {
+      if (!match(url, item)) continue;
+      let timeout = 'timeline' in item ? 2500 * item.timeline + 3000
+                  : 'timeout'  in item ? 1000 * (item.timeout - 3)
+                  : 10000;
+      console.log("Setting time out of " + timeout + " for: " + url);
+      window.setTimeout(function () {
+        console.log("Time is out for: " + url);
+        %GetAndResetRuntimeCallStats(1);
+      }, timeout);
+      return;
+    }
+    console.log("Ignoring: " + url);
+  };
+
+  let sites =
+    """, json.dumps(sites), """;
+
+  console.log("Event listenner added for: " + window.location.href);
+  window.addEventListener("load", onLoad);
+})();"""
 
 
 def run_site(site, domain, args, timeout=None):
   print "="*80
   print "RUNNING DOMAIN %s" % domain
   print "="*80
   result_template = "{domain}#{count}.txt" if args.repeat else "{domain}.txt"
   count = 0
+  if timeout is None: timeout = args.timeout
+  if args.replay_wpr: timeout += 1
   while count == 0 or args.repeat is not None and count < args.repeat:
     count += 1
     result = result_template.format(domain=domain, count=count)
     retries = 0
     while args.retries is None or retries < args.retries:
       retries += 1
       try:
-        temp_user_data_dir = args.user_data_dir is None
-        if temp_user_data_dir:
+        if args.user_data_dir:
+          user_data_dir = args.user_data_dir
+        else:
           user_data_dir = tempfile.mkdtemp(prefix="chr_")
         js_flags = "--runtime-call-stats"
+        if args.replay_wpr: js_flags += " --allow-natives-syntax"
         if args.js_flags: js_flags += " " + args.js_flags
         chrome_flags = [
             "--no-default-browser-check",
             "--disable-translate",
-            "--single-process",
+            "--disable-seccomp-sandbox",
             "--no-sandbox",
             "--js-flags={}".format(js_flags),
             "--no-first-run",
             "--user-data-dir={}".format(user_data_dir),
         ]
         if args.replay_wpr:
           chrome_flags += [
               "--host-resolver-rules=MAP *:80 localhost:4080, "  \
                                     "MAP *:443 localhost:4443, " \
                                     "EXCLUDE localhost",
               "--ignore-certificate-errors",
               "--disable-web-security",
               "--reduce-security-for-testing",
               "--allow-insecure-localhost",
           ]
+        else:
+          chrome_flags += [
+            "--single-process",
+          ]
         if args.chrome_flags:
           chrome_flags += args.chrome_flags.split()
-        if timeout is None: timeout = args.timeout
         cmd_args = [
             "timeout", str(timeout),
             args.with_chrome
         ] + chrome_flags + [ site ]
         print "- " * 40
         print_command(cmd_args)
         print "- " * 40
         with open(result, "wt") as f:
           status = subprocess.call(cmd_args, stdout=f)
         # 124 means timeout killed chrome, 0 means the user was bored first!
         # If none of these two happened, then chrome apparently crashed, so
         # it must be called again.
         if status != 124 and status != 0:
           print("CHROME CRASHED, REPEATING RUN");
           continue
         # If the stats file is empty, chrome must be called again.
         if os.path.isfile(result) and os.path.getsize(result) > 0:
           if args.print_url:
             with open(result, "at") as f:
               print >> f
               print >> f, "URL: {}".format(site)
           break
+        if retries <= 5: timeout += 1
         print("EMPTY RESULT, REPEATING RUN");
       finally:
-        if temp_user_data_dir:
+        if not args.user_data_dir:
           shutil.rmtree(user_data_dir)
 
 
 def read_sites_file(args):
   try:
     sites = []
     try:
       with open(args.sites_file, "rt") as f:
         for item in json.load(f):
           if 'timeout' not in item:
@@ skipping 10 matching lines @@
     return sites
   except IOError as e:
     args.error("Cannot read from {}. {}.".format(args.sites_file, e.strerror))
     sys.exit(1)
 
 
 def do_run(args):
   # Determine the websites to benchmark.
   if args.sites_file:
     sites = read_sites_file(args)
-  elif args.sites:
+  else:
     sites = [{'url': site, 'timeout': args.timeout} for site in args.sites]
-  else:
-    sites = [{'url': site, 'timeout': args.timeout} for site in DEFAULT_SITES]
   # Disambiguate domains, if needed.
   L = []
   domains = {}
   for item in sites:
     site = item['url']
     m = re.match(r'^(https?://)?([^/]+)(/.*)?$', site)
     if not m:
       args.error("Invalid URL {}.".format(site))
       continue
     domain = m.group(2)
     entry = [site, domain, None, item['timeout']]
     if domain not in domains:
       domains[domain] = entry
     else:
       if not isinstance(domains[domain], int):
         domains[domain][2] = 1
         domains[domain] = 1
       domains[domain] += 1
       entry[2] = domains[domain]
     L.append(entry)
-  if args.replay_wpr:
-    replay_server = start_replay_server(args);
+  replay_server = start_replay_server(args, sites) if args.replay_wpr else None
   try:
     # Run them.
     for site, domain, count, timeout in L:
       if count is not None: domain = "{}%{}".format(domain, count)
       print site, domain, timeout
       run_site(site, domain, args, timeout)
   finally:
     if replay_server:
       stop_replay_server(replay_server)
 
@@ skipping 177 matching lines @@
     if args.help_cmd in subparsers:
       subparsers[args.help_cmd].print_help()
     else:
       args.error("Unknown command '{}'".format(args.help_cmd))
   else:
     parser.print_help()
 
 
 # Main program, parse command line and execute.
 
+def coexist(*l):
+  given = sum(1 for x in l if x)
+  return given == 0 or given == len(l)
+
 def main():
   parser = argparse.ArgumentParser()
   subparser_adder = parser.add_subparsers(title="commands", dest="command",
                                           metavar="<command>")
   subparsers = {}
   # Command: run.
   subparsers["run"] = subparser_adder.add_parser(
       "run", help="run --help")
   subparsers["run"].set_defaults(
       func=do_run, error=subparsers["run"].error)
@@ skipping 64 matching lines @@
   subparsers["help"] = subparser_adder.add_parser(
       "help", help="help information")
   subparsers["help"].set_defaults(
       func=lambda args: do_help(parser, subparsers, args),
       error=subparsers["help"].error)
   subparsers["help"].add_argument(
       "help_cmd", type=str, metavar="<command>", nargs="?",
       help="command for which to display help")
   # Execute the command.
   args = parser.parse_args()
-  if args.command == "run" and args.sites_file and args.sites:
-    args.error("if --sites-file is used, no site URLS must be given")
+  setattr(args, 'script_path', os.path.dirname(sys.argv[0]))
+  if args.command == "run" and coexist(args.sites_file, args.sites):
+    args.error("use either option --sites-file or site URLs")
     sys.exit(1)
-  elif args.command == "run" and args.replay_wpr and not args.replay_bin:
-    args.error("if --replay-wpr is used, --replay-bin must be given")
+  elif args.command == "run" and not coexist(args.replay_wpr, args.replay_bin):
+    args.error("options --replay-wpr and --replay-bin must be used together")
     sys.exit(1)
   else:
     args.func(args)
 
 if __name__ == "__main__":
   sys.exit(main())