Use worker pools in go.sh/databasebuilder.py.

sdk/lib/html/scripts/databasebuilder.py

 #!/usr/bin/python
 # Copyright (c) 2011, the Dart project authors.  Please see the AUTHORS file
 # for details. All rights reserved. Use of this source code is governed by a
 # BSD-style license that can be found in the LICENSE file.
 
 import copy
 import database
 import idlparser
 import logging
 import multiprocessing
@@ skipping 56 matching lines @@
     content = f.read()
     f.close()
 
     idl_ast = idl_parser.parse(
       content,
       defines=import_options.idl_defines)
     return IDLFile(idl_ast, file_name)
   except SyntaxError, e:
     raise RuntimeError('Failed to load file %s: %s'
                        % (file_name, e))
- 
-def _load_idl_file_to_queue(file_name, import_options, result_queue):
-  """Loads an IDL file into a result_queue to process in the master thread"""
-  try:
-    result = _load_idl_file(file_name, import_options)
-    result_queue.put(result, False)
-    return 0
-  except RuntimeError, e:
-    result_queue.put(e, False)
-    return 1
-  except:
-    result_queue.put('Unknown error loading %s' % file_name, False)
-    return 1
+
 
 class DatabaseBuilder(object):
   def __init__(self, database):
     """DatabaseBuilder is used for importing and merging interfaces into
     the Database"""
     self._database = database
     self._imported_interfaces = []
     self._impl_stmts = []
 
   def _resolve_type_defs(self, idl_file):
@@ skipping 322 matching lines @@
     # Step 4: Resolve 'implements' statements
     for impl_stmt, import_options in self._impl_stmts:
       self._merge_impl_stmt(impl_stmt, import_options)
 
     self._impl_stmts = []
     self._imported_interfaces = []
 
   def import_idl_files(self, file_paths, import_options, parallel):
     if parallel:
       # Parse the IDL files in parallel.
-      result_queue = multiprocessing.Queue(len(file_paths))
-      jobs = [ multiprocessing.Process(target=_load_idl_file_to_queue,
-                                       args=(file_path, import_options,
-                                             result_queue))
-               for file_path in file_paths ]
+      pool = multiprocessing.Pool()
       try:
-        for job in jobs:
-          job.start()
-        for job in jobs:
-          # Timeout and throw after 5 sec.
-          result = result_queue.get(True, 5)
-          if isinstance(result, IDLFile):
-            self._process_idl_file(result, import_options)
-          else:
-            raise result
+        for file_path in file_paths:
+          pool.apply_async(_load_idl_file,
+                           [ file_path, import_options],
+                           callback = lambda idl_file:
+                             self._process_idl_file(idl_file, import_options))
+        pool.close()
+        pool.join()
       except:
-        # Clean up child processes on error.
-        for job in jobs:
-          job.terminate()
+        pool.terminate()
         raise
     else:
       # Parse the IDL files in serial.
       for file_path in file_paths:
         idl_file = _load_idl_file(file_path, import_options)
         self._process_idl_file(idl_file, import_options)
 
   def _process_idl_file(self, idl_file,
                         import_options):
     self._strip_ext_attributes(idl_file)
@@ skipping 118 matching lines @@
       # TODO(antonm): Ideally we'd like to have pristine copy of WebKit IDLs and fetch
       # this information directly from it.  Unfortunately right now database is massaged
       # a lot so it's difficult to maintain necessary information on DOMWindow itself.
       interface = self._database.GetInterface(type)
       if 'V8EnabledPerContext' in attr.ext_attrs:
         interface.ext_attrs['synthesizedV8EnabledPerContext'] = \
             attr.ext_attrs['V8EnabledPerContext']
       if 'V8EnabledAtRuntime' in attr.ext_attrs:
         interface.ext_attrs['synthesizedV8EnabledAtRuntime'] = \
             attr.ext_attrs['V8EnabledAtRuntime'] or attr.id