Merge remote branch 'cros/upstream' into master.

client/tests/kvm/kvm_scheduler.py

 import os, select
 import kvm_utils, kvm_vm, kvm_subprocess
 
 
 class scheduler:
     """
     A scheduler that manages several parallel test execution pipelines on a
     single host.
     """
 
@@ skipping 45 matching lines @@
         while True:
             cmd = r.readline().split()
             if not cmd:
                 continue
 
             # The scheduler wants this worker to run a test
             if cmd[0] == "run":
                 test_index = int(cmd[1])
                 test = self.tests[test_index].copy()
                 test.update(self_dict)
-                test = kvm_utils.get_sub_pool(test, index, self.num_workers)
                 test_iterations = int(test.get("iterations", 1))
                 status = run_test_func("kvm", params=test,
                                        tag=test.get("shortname"),
                                        iterations=test_iterations)
                 w.write("done %s %s\n" % (test_index, status))
                 w.write("ready\n")
 
             # The scheduler wants this worker to free its used resources
             elif cmd[0] == "cleanup":
                 env_filename = os.path.join(self.bindir, self_dict["env"])
@@ skipping 45 matching lines @@
 
                 # A worker completed a test
                 elif msg[0] == "done":
                     test_index = int(msg[1])
                     test = self.tests[test_index]
                     status = int(eval(msg[2]))
                     test_status[test_index] = ("fail", "pass")[status]
                     # If the test failed, mark all dependent tests as "failed" too
                     if not status:
                         for i, other_test in enumerate(self.tests):
-                            for dep in other_test.get("depend", []):
+                            for dep in other_test.get("dep", []):
                                 if dep in test["name"]:
                                     test_status[i] = "fail"
 
                 # A worker is done shutting down its VMs and other processes
                 elif msg[0] == "cleanup_done":
                     used_cpus[worker_index] = 0
                     used_mem[worker_index] = 0
                     closing_workers.remove(worker_index)
 
             if not someone_is_ready:
                 continue
 
             for worker in idle_workers[:]:
                 # Find a test for this worker
                 test_found = False
                 for i, test in enumerate(self.tests):
                     # We only want "waiting" tests
                     if test_status[i] != "waiting":
                         continue
                     # Make sure the test isn't assigned to another worker
                     if test_worker[i] is not None and test_worker[i] != worker:
                         continue
                     # Make sure the test's dependencies are satisfied
                     dependencies_satisfied = True
-                    for dep in test["depend"]:
+                    for dep in test["dep"]:
                         dependencies = [j for j, t in enumerate(self.tests)
                                         if dep in t["name"]]
                         bad_status_deps = [j for j in dependencies
                                            if test_status[j] != "pass"]
                         if bad_status_deps:
                             dependencies_satisfied = False
                             break
                     if not dependencies_satisfied:
                         continue
                     # Make sure we have enough resources to run the test
@@ skipping 25 matching lines @@
                         continue
                     # Everything is OK -- run the test
                     test_status[i] = "running"
                     test_worker[i] = worker
                     idle_workers.remove(worker)
                     # Update used_cpus and used_mem
                     used_cpus[worker] = test_used_cpus
                     used_mem[worker] = test_used_mem
                     # Assign all related tests to this worker
                     for j, other_test in enumerate(self.tests):
-                        for other_dep in other_test["depend"]:
+                        for other_dep in other_test["dep"]:
                             # All tests that depend on this test
                             if other_dep in test["name"]:
                                 test_worker[j] = worker
                                 break
                             # ... and all tests that share a dependency
                             # with this test
-                            for dep in test["depend"]:
+                            for dep in test["dep"]:
                                 if dep in other_dep or other_dep in dep:
                                     test_worker[j] = worker
                                     break
                     # Tell the worker to run the test
                     self.s2w_w[worker].write("run %s\n" % i)
                     break
 
                 # If there won't be any tests for this worker to run soon, tell
                 # the worker to free its used resources
                 if not test_found and (used_cpus[worker] or used_mem[worker]):
                     self.s2w_w[worker].write("cleanup\n")
                     idle_workers.remove(worker)
                     closing_workers.append(worker)
 
             # If there are no more new tests to run, terminate the workers and
             # the scheduler
             if len(idle_workers) == self.num_workers:
                 for worker in idle_workers:
                     self.s2w_w[worker].write("terminate\n")
                 break