[lit] Use better name for "test in parallel" concept

[yln]

Summary

In the past, lit used threads to run tests in parallel. Today we use
multiprocessing.Pool, which uses processes. Let's stay more abstract
and use "worker" everywhere.

[rnk]

lgtm

llvm/trunk/utils/lit/lit/main.py

def main_with_tmp(builtinParameters):
     parser = argparse.ArgumentParser()
     parser.add_argument('test_paths',
                         nargs='*',
                         help='Files or paths to include in the test suite')
 
     parser.add_argument("--version", dest="show_version",
                       help="Show version and exit",
                       action="store_true", default=False)
-    parser.add_argument("-j", "--threads", dest="numThreads", metavar="N",
-                      help="Number of testing threads",
+    parser.add_argument("-j", "--threads", "--workers", dest="numWorkers", metavar="N",
+                      help="Number of workers used for testing",
                       type=int, default=None)
     parser.add_argument("--config-prefix", dest="configPrefix",
                       metavar="NAME", help="Prefix for 'lit' config files",
                       action="store", default=None)
     parser.add_argument("-D", "--param", dest="userParameters",
                       metavar="NAME=VAL",
                       help="Add 'NAME' = 'VAL' to the user defined parameters",
                       type=str, action="append", default=[])
def main_with_tmp(builtinParameters):
 
     if opts.show_version:
         print("lit %s" % (lit.__version__,))
         return
 
     if not args:
         parser.error('No inputs specified')
 
-    if opts.numThreads is None:
-        opts.numThreads = lit.util.detectCPUs()
-    elif opts.numThreads <= 0:
-        parser.error("Option '--threads' or '-j' requires positive integer")
+    if opts.numWorkers is None:
+        opts.numWorkers = lit.util.detectCPUs()
+    elif opts.numWorkers <= 0:
+        parser.error("Option '--workers' or '-j' requires positive integer")
 
     if opts.maxFailures is not None and opts.maxFailures <= 0:
         parser.error("Option '--max-failures' requires positive integer")
 
     if opts.echoAllCommands:
         opts.showOutput = True
 
     inputs = args
if (opts.numShards is not None) or (opts.runShard is not None):
                        (opts.runShard, opts.numShards,
                         len(run.tests), num_tests,
                         opts.numShards, opts.runShard, ix_preview))
 
     # Finally limit the number of tests, if desired.
     if opts.maxTests is not None:
         run.tests = run.tests[:opts.maxTests]
 
-    # Don't create more threads than tests.
-    opts.numThreads = min(len(run.tests), opts.numThreads)
+    # Don't create more workers than tests.
+    opts.numWorkers = min(len(run.tests), opts.numWorkers)
 
     # Because some tests use threads internally, and at least on Linux each
     # of these threads counts toward the current process limit, try to
     # raise the (soft) process limit so that tests don't fail due to
     # resource exhaustion.
     try:
         cpus = lit.util.detectCPUs()
-        desired_limit = opts.numThreads * cpus * 2 # the 2 is a safety factor
+        desired_limit = opts.numWorkers * cpus * 2 # the 2 is a safety factor
 
         # Import the resource module here inside this try block because it
         # will likely fail on Windows.
         import resource
 
         max_procs_soft, max_procs_hard = resource.getrlimit(resource.RLIMIT_NPROC)
         desired_limit = min(desired_limit, max_procs_hard)
 
         if max_procs_soft < desired_limit:
             resource.setrlimit(resource.RLIMIT_NPROC, (desired_limit, max_procs_hard))
             litConfig.note('raised the process limit from %d to %d' % \
                                (max_procs_soft, desired_limit))
     except:
         pass
 
     extra = (' of %d' % numTotalTests) if (len(run.tests) != numTotalTests) else ''
-    threads = 'single process' if (opts.numThreads == 1) else ('%d threads' % opts.numThreads)
-    header = '-- Testing: %d%s tests, %s --' % (len(run.tests), extra, threads)
+    header = '-- Testing: %d%s tests, %d workers --' % (len(run.tests), extra, opts.numWorkers)
     progressBar = None
     if not opts.quiet:
         if opts.succinct and opts.useProgressBar:
             try:
                 tc = lit.ProgressBar.TerminalController()
                 progressBar = lit.ProgressBar.ProgressBar(tc, header)
             except ValueError:
                 print(header)
                 progressBar = lit.ProgressBar.SimpleProgressBar('Testing: ')
         else:
             print(header)
 
     startTime = time.time()
     display = TestingProgressDisplay(opts, len(run.tests), progressBar)
     try:
-        run.execute_tests(display, opts.numThreads, opts.maxTime)
+        run.execute_tests(display, opts.numWorkers, opts.maxTime)
     except KeyboardInterrupt:
         sys.exit(2)
     display.finish()
 
     testing_time = time.time() - startTime
     if not opts.quiet:
         print('Testing Time: %.2fs' % (testing_time,))
 

llvm/trunk/utils/lit/lit/run.py

def __init__(self, lit_config, tests):
         self.lit_config = lit_config
         self.tests = tests
         # Set up semaphores to limit parallelism of certain classes of tests.
         self.parallelism_semaphores = {
                 k : NopSemaphore() if v is None else
                     multiprocessing.BoundedSemaphore(v)
                 for k, v in lit_config.parallelism_groups.items()}
 
-    def execute_tests_in_pool(self, jobs, max_time):
+    def _execute_tests_in_pool(self, workers, max_time):
         # We need to issue many wait calls, so compute the final deadline and
         # subtract time.time() from that as we go along.
         deadline = None
         if max_time:
             deadline = time.time() + max_time
 
         # Start a process pool. Copy over the data shared between all test runs.
         # FIXME: Find a way to capture the worker process stderr. If the user
         # interrupts the workers before we make it into our task callback, they
         # will each raise a KeyboardInterrupt exception and print to stderr at
         # the same time.
-        pool = multiprocessing.Pool(jobs, lit.worker.initializer,
+        pool = multiprocessing.Pool(workers, lit.worker.initializer,
                                     (self.lit_config,
                                      self.parallelism_semaphores))
 
         # Install a console-control signal handler on Windows.
         if lit.util.win32api is not None:
             def console_ctrl_handler(type):
                 print('\nCtrl-C detected, terminating.')
                 pool.terminate()
def _execute_tests_in_pool(self, workers, max_time):
         except:
             # Stop the workers and wait for any straggling results to come in
             # if we exited without waiting on every async result.
             pool.terminate()
             raise
         finally:
             pool.join()
 
-    def execute_tests(self, display, jobs, max_time=None):
+    def execute_tests(self, display, workers, max_time=None):
         """
-        execute_tests(display, jobs, [max_time])
+        execute_tests(display, workers, [max_time])
 
-        Execute each of the tests in the run, using up to jobs number of
+        Execute the tests in the run using up to the specified number of
         parallel tasks, and inform the display of each individual result. The
         provided tests should be a subset of the tests available in this run
         object.
 
         If max_time is non-None, it should be a time in seconds after which to
         stop executing tests.
 
-        The display object will have its update method called with each test as
-        it is completed. The calls are guaranteed to be locked with respect to
-        one another, but are *not* guaranteed to be called on the same thread as
-        this method was invoked on.
+        The display object will have its update method called for each completed
+        test.
 
         Upon completion, each test in the run will have its result
         computed. Tests which were not actually executed (for any reason) will
         be given an UNRESOLVED result.
         """
         # Don't do anything if we aren't going to run any tests.
         if not self.tests:
             return
 
         # Save the display object on the runner so that we can update it from
         # our task completion callback.
         self.display = display
 
         self.failure_count = 0
         self.hit_max_failures = False
-        if jobs == 1:
+        if workers == 1:
             for test_index, test in enumerate(self.tests):
                 lit.worker._execute_test(test, self.lit_config)
                 self.consume_test_result((test_index, test))
                 if self.hit_max_failures:
                     break
         else:
-            self.execute_tests_in_pool(jobs, max_time)
+            self._execute_tests_in_pool(workers, max_time)
 
         # Mark any tests that weren't run as UNRESOLVED.
         for test in self.tests:
             if test.result is None:
                 test.setResult(lit.Test.Result(lit.Test.UNRESOLVED, '', 0.0))
 
     def consume_test_result(self, pool_result):
         """Test completion callback for lit.worker.run_one_test

llvm/trunk/utils/lit/tests/discovery.py

 # CHECK-BASIC-OUT: top-level-suite :: subdir/test-three
 # CHECK-BASIC-OUT: top-level-suite :: test-one
 # CHECK-BASIC-OUT: top-level-suite :: test-two
 
 # Check discovery when providing the special builtin 'config_map'
 # RUN: %{python} %{inputs}/config-map-discovery/driver.py \
 # RUN:           %{inputs}/config-map-discovery/main-config/lit.cfg \
 # RUN:           %{inputs}/config-map-discovery/lit.alt.cfg \
-# RUN:           --threads=1 --debug --show-tests --show-suites > %t.out 2> %t.err
+# RUN:           --workers=1 --debug --show-tests --show-suites > %t.out 2> %t.err
 # RUN: FileCheck --check-prefix=CHECK-CONFIG-MAP-OUT < %t.out %s
 # RUN: FileCheck --check-prefix=CHECK-CONFIG-MAP-ERR < %t.err %s
 
 # CHECK-CONFIG-MAP-OUT-NOT: ERROR: lit.cfg invoked
 # CHECK-CONFIG-MAP-OUT: -- Test Suites --
 # CHECK-CONFIG-MAP-OUT:   config-map - 2 tests
 # CHECK-CONFIG-MAP-OUT:     Source Root: {{.*[/\\]config-map-discovery[/\\]tests}}
 # CHECK-CONFIG-MAP-OUT:     Exec Root  : {{.*[/\\]tests[/\\]Inputs[/\\]config-map-discovery}}

llvm/trunk/utils/lit/tests/parallelism-groups.py

 #   config.parallelism_group = 'my_group'
 #
 # Note: We need at least 2 tests to prevent lit from using "single process
 #       mode", which ignores parallelism groups.
 #
 
 # RUN: %{lit} -j2 %{inputs}/parallelism-groups | FileCheck %s
 
-# CHECK:     -- Testing: 2 tests, 2 threads --
+# CHECK:     -- Testing: 2 tests, 2 workers --
 # CHECK-DAG: PASS: parallelism-groups :: test1.txt
 # CHECK-DAG: PASS: parallelism-groups :: test2.txt
 # CHECK:     Expected Passes    : 2