[tools] Specify affinity and raise priority when benchmarking

tools/run_perf.py

 #!/usr/bin/env python
 # Copyright 2014 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.
 
 """
 Performance runner for d8.
 
 Call e.g. with tools/run-perf.py --arch ia32 some_suite.json
 
@@ skipping 594 matching lines @@
     stdout = self._Run(runnable, count, no_patch=False)
     if self.shell_dir_no_patch:
       return stdout, self._Run(runnable, count, no_patch=True)
     else:
       return stdout, None
 
 
 class DesktopPlatform(Platform):
   def __init__(self, options):
     super(DesktopPlatform, self).__init__(options)
+    self.command_prefix = []
+
+    if options.prioritize or options.affinitize != None:
+      self.command_prefix = ["schedtool"]
+      if options.prioritize:
+        self.command_prefix += ["-n", "-20"]
+      if options.affinitize != None:
+      # schedtool expects a bit pattern when setting affinity, where each
+      # bit set to '1' corresponds to a core where the process may run on.
+      # First bit corresponds to CPU 0. Since the 'affinitize' parameter is
+      # a core number, we need to map to said bit pattern.
+        cpu = int(options.affinitize)
+        core = 1 << cpu
+        self.command_prefix += ["-a", ("0x%x" % core)]

[Michael Achenbach, 2016/04/28 13:03:07]

Another question to this: Now we set exactly one core. Does that sacrifice
performance for v8 (as v8 is multi-threaded)? Would we not get equally stable
results (without sacrificing speed) with a pattern that sets several cores but
avoids core 0? Like 0xe

[Mircea Trofin, 2016/04/28 14:21:57]

Multi-core may introduce other sources of variance, for instance, if the cores
are not sharing caches. For my goal - stable measurements for codegen - I may
even need to avoid v8's multi-threading altogether.

+      self.command_prefix += ["-e"]
 
   def PreExecution(self):
     pass
 
   def PostExecution(self):
     pass
 
   def PreTests(self, node, path):
     if isinstance(node, RunnableConfig):
       node.ChangeCWD(path)
 
   def _Run(self, runnable, count, no_patch=False):
     suffix = ' - without patch' if no_patch else ''
     shell_dir = self.shell_dir_no_patch if no_patch else self.shell_dir
     title = ">>> %%s (#%d)%s:" % ((count + 1), suffix)
+    command = self.command_prefix + runnable.GetCommand(shell_dir,
+                                                        self.extra_flags)
     try:
       output = commands.Execute(
-          runnable.GetCommand(shell_dir, self.extra_flags),
-          timeout=runnable.timeout,
+        command,
+        timeout=runnable.timeout,
       )
     except OSError as e:  # pragma: no cover
       print title % "OSError"
       print e
       return ""
+
     print title % "Stdout"
     print output.stdout
     if output.stderr:  # pragma: no cover
       # Print stderr for debugging.
       print title % "Stderr"
       print output.stderr
     if output.timed_out:
       print ">>> Test timed out after %ss." % runnable.timeout
     if '--prof' in self.extra_flags:
       os_prefix = {"linux": "linux", "macos": "mac"}.get(utils.GuessOS())
@@ skipping 133 matching lines @@
       )
       stdout = "\n".join(output)
       print title % "Stdout"
       print stdout
     except device_errors.CommandTimeoutError:
       print ">>> Test timed out after %ss." % runnable.timeout
       stdout = ""
     return stdout
 
 
+def GetASLR():
+  try:
+    f = os.open("/proc/sys/kernel/randomize_va_space", os.O_RDONLY)

[Michael Achenbach, 2016/04/28 14:47:44]

Could you use with clauses? Also below.
with open("/proc/sys/kernel/randomize_va_space") as f:
  return int(f.read().strip())

[Mircea Trofin, 2016/04/28 16:02:46]

Done.

+    val = os.read(f, 1)
+    os.close(f)
+    return int(val)
+  except Exception as e:
+    print "Failed to get current ASLR settings."
+    raise e
+
+def SetASLR(value):
+  try:
+    f = os.open("/proc/sys/kernel/randomize_va_space", os.O_WRONLY)
+    val = os.write(f, str(value))
+    os.close(f)
+
+    new_value = GetASLR()
+    if value != new_value: raise Exception("Present value is %s" % new_value)

[Michael Achenbach, 2016/04/28 14:47:44]

Maybe move this condition outside the try block to avoid catching rethrowing
this exception.

[Mircea Trofin, 2016/04/28 16:02:46]

Done.

+  except Exception as e:
+    print "Failed to update ASLR to %s." % value
+    raise e
+
+def GetCPUCoresRange():
+  try:
+    f = open("/sys/devices/system/cpu/present", "r")
+    indexes = f.readline()
+    [first, last] = map(int, indexes.split("-"))

[Michael Achenbach, 2016/04/28 14:47:44]

first, last = map(int, indexes.split("-"))
should work

[Mircea Trofin, 2016/04/28 16:02:47]

Done.

+    return range(first, last + 1)
+  except Exception as e:
+    print "Failed to retrieve CPU governor value"
+    raise e
+
+def GetCPUPathForId(cpu_index):
+  ret = "/sys/devices/system/cpu/cpu"
+  ret += str(cpu_index)
+  ret += "/cpufreq/scaling_governor"
+  return ret
+
+def GetCPUGovernor():
+  try:
+    cpu_indices = GetCPUCoresRange()
+    ret = None
+    for cpu_index in cpu_indices:

[Michael Achenbach, 2016/04/28 14:47:44]

nit: Maybe inline GetCPUCoresRange()
also in method below

[Mircea Trofin, 2016/04/28 16:02:46]

I didn't understand what you meant here.

[Michael Achenbach, 2016/04/29 07:40:32]

I meant to skip the local variable. But now that the name got longer it's only
useful if you don't breach the 80 char limit:

cpu_indices = CustomMachineConfiguration.GetCPUCoresRange()
for cpu_index in cpu_indices:

into

for cpu_index in CustomMachineConfiguration.GetCPUCoresRange():

+      f = open(GetCPUPathForId(cpu_index), "r")
+      # We assume the governors of all CPUs are set to the same value
+      val = f.readline().strip()
+      f.close()
+      if ret == None:
+        ret = val
+      else:

[Michael Achenbach, 2016/04/28 14:47:44]

elif ret != val:

[Mircea Trofin, 2016/04/28 16:02:46]

Done.

+        if ret != val:
+          raise Exception("CPU cores have differing governor settings")
+    return ret
+  except Exception as e:
+    print "Failed to get the current CPU governor."
+    raise e
+
+
+def SetCPUGovernor(value):
+  try:
+    cpu_indices = GetCPUCoresRange()
+    for cpu_index in cpu_indices:
+      f = open(GetCPUPathForId(cpu_index), "w")
+      f.write(value)
+      f.close()
+
+    cur_value = GetCPUGovernor()
+    if cur_value != value:

[Michael Achenbach, 2016/04/28 14:47:44]

same as above - move condition outside try

[Mircea Trofin, 2016/04/28 16:02:46]

Done.

+      raise Exception("Could not set CPU governor. Present value is %s"
+                      % cur_value )
+  except Exception as e:
+    print "Failed to change CPU governor to %s." % value
+    raise e
+
 # TODO: Implement results_processor.
 def Main(args):
   logging.getLogger().setLevel(logging.INFO)
   parser = optparse.OptionParser()
   parser.add_option("--android-build-tools",
                     help="Path to chromium's build/android. Specifying this "
                          "option will run tests using android platform.")
   parser.add_option("--arch",
                     help=("The architecture to run tests for, "
                           "'auto' or 'native' for auto-detect"),
@@ skipping 13 matching lines @@
                     help="Path to a file for storing json results from run "
                          "without patch.")
   parser.add_option("--outdir", help="Base directory with compile output",
                     default="out")
   parser.add_option("--outdir-no-patch",
                     help="Base directory with compile output without patch")
   parser.add_option("--binary-override-path",
                     help="JavaScript engine binary. By default, d8 under "
                     "architecture-specific build dir. "
                     "Not supported in conjunction with outdir-no-patch.")
+  parser.add_option("--prioritize",
+                    help="Raise the priority to nice -20 for the benchmarking"
+                    "process.Requires Linux, schedtool, and sudo privileges.",
+                    default=False, action="store_true")
+  parser.add_option("--affinitize",
+                    help="Run benchmarking process on the specified core."
+                    "For example:"
+                    "--affinitize=0 will run the benchmark process on core 0."
+                    "--affinitize=3 will run the benchmark process on core 3."
+                    "Requires Linux, schedtool, and sudo privileges.",
+                    default=None)
+  parser.add_option("--noaslr",
+                    help="Disable ASLR for the duration of the benchmarked"
+                    "process. Requires Linux and sudo privileges.",
+                    default=False, action="store_true")
+  parser.add_option("--cpu-governor",
+                    help="Set cpu governor to specified policy for the"

[Michael Achenbach, 2016/04/28 14:47:43]

nit: Space before " to not concatenate strings.

[Mircea Trofin, 2016/04/28 16:02:46]

Done.

+                    "duration of the benchmarked process. Typical options:"
+                    "'powersave' for more stable results, or 'performance'"
+                    "for shorter completion time of suite, with potentially"
+                    "more noise in results.")
 
   (options, args) = parser.parse_args(args)
 
   if len(args) == 0:  # pragma: no cover
     parser.print_help()
     return 1
 
   if options.arch in ["auto", "native"]:  # pragma: no cover
     options.arch = ARCH_GUESS
 
@@ skipping 30 matching lines @@
       return 1
     options.shell_dir = os.path.dirname(options.binary_override_path)
     default_binary_name = os.path.basename(options.binary_override_path)
 
   if options.outdir_no_patch:
     options.shell_dir_no_patch = os.path.join(
         workspace, options.outdir_no_patch, build_config)
   else:
     options.shell_dir_no_patch = None
 
+  prev_aslr = None
+  prev_cpu_gov = None
+  if options.noaslr:
+    prev_aslr = GetASLR()
+    SetASLR(0)
+  if options.cpu_governor:
+    prev_cpu_gov = GetCPUGovernor()
+    SetCPUGovernor(options.cpu_governor)
+
   platform = Platform.GetPlatform(options)
 
   results = Results()
   results_no_patch = Results()
   for path in args:
     path = os.path.abspath(path)
 
     if not os.path.exists(path):  # pragma: no cover
       results.errors.append("Configuration file %s does not exist." % path)
       continue
@@ skipping 25 matching lines @@
           # TODO(machenbach): Allow timeout per arch like with run_count per
           # arch.
           yield platform.Run(runnable, i)
 
       # Let runnable iterate over all runs and handle output.
       result, result_no_patch = runnable.Run(
           Runner, trybot=options.shell_dir_no_patch)
       results += result
       results_no_patch += result_no_patch
     platform.PostExecution()
 

[Michael Achenbach, 2016/04/28 14:47:44]

Please refactor and put everything between setting/unsetting these things into a
separate method. Then put it in a "try" clause and put the code below into
"finally" to make sure we reset to original state also on other test runner
errors.

To make it easier, maybe move the reset code to the end of this method.

[Mircea Trofin, 2016/04/28 16:02:47]

Thanks for the suggestion - this makes sense. I moved it all under a resource
class.

[Michael Achenbach, 2016/04/29 07:40:32]

Very nice!

+  if prev_aslr != None:
+    SetASLR(prev_aslr)
+  if prev_cpu_gov != None:
+    SetCPUGovernor(prev_cpu_gov)
+
   if options.json_test_results:
     results.WriteToFile(options.json_test_results)
   else:  # pragma: no cover
     print results
 
   if options.json_test_results_no_patch:
     results_no_patch.WriteToFile(options.json_test_results_no_patch)
   else:  # pragma: no cover
     print results_no_patch
 
   return min(1, len(results.errors))
 
 if __name__ == "__main__":  # pragma: no cover
   sys.exit(Main(sys.argv[1:]))