Python OPTIONS.configure_jobs方法代码示例

# 需要导入模块: from src.build.build_options import OPTIONS [as 别名]
# 或者: from src.build.build_options.OPTIONS import configure_jobs [as 别名]
def _generate_shared_lib_depending_ninjas(ninja_list):
  timer = build_common.SimpleTimer()

  timer.start('Generating plugin and packaging ninjas', OPTIONS.verbose())
  # We must generate plugin/nexe ninjas after make->ninja lazy generation
  # so that we have the full list of production shared libraries to
  # pass to the load test.
  # These modules depend on shared libraries generated in the previous phase.
  production_shared_libs = (
      ninja_generator.NinjaGenerator.get_production_shared_libs(ninja_list[:]))
  generator_list = list(_list_ninja_generators(
      _config_loader, 'generate_shared_lib_depending_ninjas'))

  if OPTIONS.run_tests():
    generator_list.extend(_list_ninja_generators(
        _config_loader, 'generate_shared_lib_depending_test_ninjas'))

  result_list = ninja_generator_runner.run_in_parallel(
      [ninja_generator_runner.GeneratorTask(
          config_context,
          (generator, production_shared_libs))
       for config_context, generator in generator_list],
      OPTIONS.configure_jobs())
  ninja_list = []
  for config_result in result_list:
    ninja_list.extend(config_result.generated_ninjas)
  ninja_list.sort(key=lambda ninja: ninja.get_module_name())

  timer.done()
  return ninja_list

# 需要导入模块: from src.build.build_options import OPTIONS [as 别名]
# 或者: from src.build.build_options.OPTIONS import configure_jobs [as 别名]
def _generate_dependent_ninjas(ninja_list):
  """Generate the stage of ninjas coming after all executables."""
  timer = build_common.SimpleTimer()

  timer.start('Generating dependent ninjas', OPTIONS.verbose())

  root_dir_install_all_targets = []
  for n in ninja_list:
    root_dir_install_all_targets.extend(build_common.get_android_fs_path(p) for
                                        p in n._root_dir_install_targets)

  generator_list = _list_ninja_generators(_config_loader,
                                          'generate_binaries_depending_ninjas')
  result_list = ninja_generator_runner.run_in_parallel(
      [ninja_generator_runner.GeneratorTask(
          config_context,
          (generator, root_dir_install_all_targets))
          for config_context, generator in generator_list],
      OPTIONS.configure_jobs())
  dependent_ninjas = []
  for config_result in result_list:
    dependent_ninjas.extend(config_result.generated_ninjas)

  notice_ninja = ninja_generator.NoticeNinjaGenerator('notices')
  notice_ninja.build_notices(ninja_list + dependent_ninjas)
  dependent_ninjas.append(notice_ninja)

  all_test_lists_ninja = ninja_generator.NinjaGenerator('all_test_lists')
  all_test_lists_ninja.build_all_test_lists(ninja_list)
  dependent_ninjas.append(all_test_lists_ninja)

  all_unittest_info_ninja = ninja_generator.NinjaGenerator('all_unittest_info')
  all_unittest_info_ninja.build_all_unittest_info(ninja_list)
  dependent_ninjas.append(all_unittest_info_ninja)

  timer.done()
  return dependent_ninjas

# 需要导入模块: from src.build.build_options import OPTIONS [as 别名]
# 或者: from src.build.build_options.OPTIONS import configure_jobs [as 别名]
def _generate_independent_ninjas(needs_clobbering):
  timer = build_common.SimpleTimer()

  # Invoke an unordered set of ninja-generators distributed across config
  # modules by name, and if that generator is marked for it.
  timer.start('Generating independent generate_ninjas', True)

  generator_list = list(_list_ninja_generators(
      _config_loader, 'generate_ninjas'))
  if OPTIONS.run_tests():
    generator_list.extend(_list_ninja_generators(
        _config_loader, 'generate_test_ninjas'))

  task_list = []
  cached_result_list = []
  cache_miss = {}

  for config_context, generator in generator_list:
    cache_path = _get_cache_file_path(config_context.config_name,
                                      config_context.entry_point)
    config_cache = None
    if OPTIONS.enable_config_cache() and not needs_clobbering:
      config_cache = _load_config_cache_from_file(cache_path)

    if config_cache is not None and config_cache.check_cache_freshness():
      cached_result = config_cache.to_config_result()
      if cached_result is not None:
        cached_result_list.append(cached_result)
        continue

    task_list.append(ninja_generator_runner.GeneratorTask(
        config_context, generator))
    cache_miss[cache_path] = config_cache

  result_list = ninja_generator_runner.run_in_parallel(
      task_list, OPTIONS.configure_jobs())

  aggregated_result = {}
  ninja_list = []
  for config_result in result_list:
    cache_path = _get_cache_file_path(config_result.config_name,
                                      config_result.entry_point)
    ninja_list.extend(config_result.generated_ninjas)
    if cache_path in aggregated_result:
      aggregated_result[cache_path].merge(config_result)
    else:
      aggregated_result[cache_path] = config_result

  for cached_result in cached_result_list:
    ninja_list.extend(cached_result.generated_ninjas)

  cache_to_save = []
  if OPTIONS.enable_config_cache():
    for cache_path, config_result in aggregated_result.iteritems():
      config_cache = cache_miss[cache_path]
      if config_cache is None:
        config_cache = _config_cache_from_config_result(config_result)
      else:
        config_cache.refresh_with_config_result(config_result)

      cache_to_save.append((config_cache, cache_path))

  ninja_list.sort(key=lambda ninja: ninja.get_module_name())
  timer.done()
  return ninja_list, cache_to_save