[Isolates] Merge crankshaft (r5922 from bleeding_edge).

tools/test.py

 #!/usr/bin/env python
 #
 # Copyright 2008 the V8 project authors. All rights reserved.
 # Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions are
 # met:
 #
 #     * Redistributions of source code must retain the above copyright
 #       notice, this list of conditions and the following disclaimer.
 #     * Redistributions in binary form must reproduce the above
@@ skipping 343 matching lines @@
   def IsFailureOutput(self, output):
     return output.exit_code != 0
 
   def GetSource(self):
     return "(no source available)"
 
   def RunCommand(self, command):
     full_command = self.context.processor(command)
     output = Execute(full_command,
                      self.context,
-                     self.context.GetTimeout(self.mode))
+                     self.context.GetTimeout(self, self.mode))
     self.Cleanup()
     return TestOutput(self,
                       full_command,
                       output,
                       self.context.store_unexpected_output)
 
   def BeforeRun(self):
     pass
 
   def AfterRun(self, result):
@@ skipping 190 matching lines @@
 
   def __init__(self, name):
     self.name = name
 
   def GetName(self):
     return self.name
 
 
 # Use this to run several variants of the tests, e.g.:
 # VARIANT_FLAGS = [[], ['--always_compact', '--noflush_code']]
-VARIANT_FLAGS = [[]]
+VARIANT_FLAGS = [[], ['--stress-opt', '--always-opt'], ['--nocrankshaft']]
 
 
 class TestRepository(TestSuite):
 
   def __init__(self, path):
     normalized_path = abspath(path)
     super(TestRepository, self).__init__(basename(normalized_path))
     self.path = normalized_path
     self.is_loaded = False
     self.config = None
@@ skipping 83 matching lines @@
     if utils.IsWindows() and not name.endswith('.exe'):
       name = name + '.exe'
     return name
 
   def GetVmCommand(self, testcase, mode):
     return [self.GetVm(mode)] + self.GetVmFlags(testcase, mode)
 
   def GetVmFlags(self, testcase, mode):
     return testcase.variant_flags + FLAGS[mode]
 
-  def GetTimeout(self, mode):
-    return self.timeout * TIMEOUT_SCALEFACTOR[mode]
+  def GetTimeout(self, testcase, mode):
+    result = self.timeout * TIMEOUT_SCALEFACTOR[mode]
+    if '--stress-opt' in self.GetVmFlags(testcase, mode):
+      return result * 2
+    else:
+      return result
 
 def RunTestCases(cases_to_run, progress, tasks):
   progress = PROGRESS_INDICATORS[progress](cases_to_run)
   return progress.Run(tasks)
 
 
 def BuildRequirements(context, requirements, mode, scons_flags):
   command_line = (['scons', '-Y', context.workspace, 'mode=' + ",".join(mode)]
                   + requirements
                   + scons_flags)
@@ skipping 468 matching lines @@
   result.add_option("-j", help="The number of parallel tasks to run",
       default=1, type="int")
   result.add_option("--time", help="Print timing information after running",
       default=False, action="store_true")
   result.add_option("--suppress-dialogs", help="Suppress Windows dialogs for crashing tests",
         dest="suppress_dialogs", default=True, action="store_true")
   result.add_option("--no-suppress-dialogs", help="Display Windows dialogs for crashing tests",
         dest="suppress_dialogs", action="store_false")
   result.add_option("--shell", help="Path to V8 shell", default="shell")
   result.add_option("--isolates", help="Whether to test isolates", default=False, action="store_true")
-  result.add_option("--store-unexpected-output", 
+  result.add_option("--store-unexpected-output",
       help="Store the temporary JS files from tests that fails",
       dest="store_unexpected_output", default=True, action="store_true")
-  result.add_option("--no-store-unexpected-output", 
+  result.add_option("--no-store-unexpected-output",
       help="Deletes the temporary JS files from tests that fails",
       dest="store_unexpected_output", action="store_false")
+  result.add_option("--stress-only",
+                    help="Only run tests with --always-opt --stress-opt",
+                    default=False, action="store_true")
+  result.add_option("--nostress",
+                    help="Don't run crankshaft --always-opt --stress-op test",
+                    default=False, action="store_true")
   return result
 
 
 def ProcessOptions(options):
   global VERBOSE
   VERBOSE = options.verbose
   options.mode = options.mode.split(',')
   for mode in options.mode:
     if not mode in ['debug', 'release']:
       print "Unknown mode %s" % mode
       return False
   if options.simulator != 'none':
     # Simulator argument was set. Make sure arch and simulator agree.
     if options.simulator != options.arch:
       if options.arch == 'none':
         options.arch = options.simulator
       else:
         print "Architecture %s does not match sim %s" %(options.arch, options.simulator)
         return False
     # Ensure that the simulator argument is handed down to scons.
     options.scons_flags.append("simulator=" + options.simulator)
   else:
     # If options.arch is not set by the command line and no simulator setting
     # was found, set the arch to the guess.
     if options.arch == 'none':
       options.arch = ARCH_GUESS
     options.scons_flags.append("arch=" + options.arch)
   if options.snapshot:
     options.scons_flags.append("snapshot=on")
+  global VARIANT_FLAGS
+  if options.stress_only:
+    VARIANT_FLAGS = [['--stress-opt', '--always-opt']]
+  if options.nostress:
+    VARIANT_FLAGS = [[],['--nocrankshaft']]
   return True
 
 
 REPORT_TEMPLATE = """\
 Total: %(total)i tests
  * %(skipped)4d tests will be skipped
  * %(nocrash)4d tests are expected to be flaky but not crash
  * %(pass)4d tests are expected to pass
  * %(fail_ok)4d tests are expected to fail that we won't fix
  * %(fail)4d tests are expected to fail that we should fix\
@@ skipping 201 matching lines @@
     for entry in timed_tests[:20]:
       t = FormatTime(entry.duration)
       sys.stderr.write("%4i (%s) %s\n" % (index, t, entry.GetLabel()))
       index += 1
 
   return result
 
 
 if __name__ == '__main__':
   sys.exit(Main())