You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
90 lines
3.4 KiB
Python
90 lines
3.4 KiB
Python
# Copyright (c) 2017 The Chromium Authors. All rights reserved.
|
|
# Use of this source code is governed by a BSD-style license that can be
|
|
# found in the LICENSE file.
|
|
|
|
"""
|
|
This script (intended to be invoked by autoninja or autoninja.bat) detects
|
|
whether a build is using goma. If so it runs with a large -j value, and
|
|
otherwise it chooses a small one. This auto-adjustment makes using goma simpler
|
|
and safer, and avoids errors that can cause slow goma builds or swap-storms
|
|
on non-goma builds.
|
|
"""
|
|
|
|
import multiprocessing
|
|
import os
|
|
import re
|
|
import sys
|
|
|
|
# The -t tools are incompatible with -j and -l
|
|
t_specified = False
|
|
j_specified = False
|
|
output_dir = '.'
|
|
input_args = sys.argv
|
|
# On Windows the autoninja.bat script passes along the arguments enclosed in
|
|
# double quotes. This prevents multiple levels of parsing of the special '^'
|
|
# characters needed when compiling a single file but means that this script gets
|
|
# called with a single argument containing all of the actual arguments,
|
|
# separated by spaces. When this case is detected we need to do argument
|
|
# splitting ourselves. This means that arguments containing actual spaces are
|
|
# not supported by autoninja, but that is not a real limitation.
|
|
if (sys.platform.startswith('win') and len(sys.argv) == 2 and
|
|
input_args[1].count(' ') > 0):
|
|
input_args = sys.argv[:1] + sys.argv[1].split()
|
|
for index, arg in enumerate(input_args[1:]):
|
|
if arg == '-j':
|
|
j_specified = True
|
|
if arg == '-t':
|
|
t_specified = True
|
|
if arg == '-C':
|
|
# + 1 to get the next argument and +1 because we trimmed off input_args[0]
|
|
output_dir = input_args[index + 2]
|
|
|
|
use_goma = False
|
|
try:
|
|
# If GOMA_DISABLED is set (to anything) then gomacc will use the local
|
|
# compiler instead of doing a goma compile. This is convenient if you want
|
|
# to briefly disable goma. It avoids having to rebuild the world when
|
|
# transitioning between goma/non-goma builds. However, it is not as fast as
|
|
# doing a "normal" non-goma build because an extra process is created for each
|
|
# compile step. Checking this environment variable ensures that autoninja uses
|
|
# an appropriate -j value in this situation.
|
|
if 'GOMA_DISABLED' not in os.environ:
|
|
with open(os.path.join(output_dir, 'args.gn')) as file_handle:
|
|
for line in file_handle:
|
|
# This regex pattern copied from create_installer_archive.py
|
|
m = re.match('^\s*use_goma\s*=\s*true(\s*$|\s*#.*$)', line)
|
|
if m:
|
|
use_goma = True
|
|
except IOError:
|
|
pass
|
|
|
|
if sys.platform.startswith('win'):
|
|
# Specify ninja.exe on Windows so that ninja.bat can call autoninja and not
|
|
# be called back.
|
|
args = ['ninja.exe'] + input_args[1:]
|
|
else:
|
|
args = ['ninja'] + input_args[1:]
|
|
|
|
num_cores = multiprocessing.cpu_count()
|
|
if not j_specified and not t_specified:
|
|
if use_goma:
|
|
args.append('-j')
|
|
core_multiplier = int(os.environ.get("NINJA_CORE_MULTIPLIER", "20"))
|
|
args.append('%d' % (num_cores * core_multiplier))
|
|
else:
|
|
core_addition = os.environ.get("NINJA_CORE_ADDITION")
|
|
if core_addition:
|
|
core_addition = int(core_addition)
|
|
args.append('-j')
|
|
args.append('%d' % (num_cores + core_addition))
|
|
|
|
if not t_specified:
|
|
# Specify a maximum CPU load so that running builds in two different command
|
|
# prompts won't overload the system too much. This is not reliable enough to
|
|
# be used to auto-adjust between goma/non-goma loads, but it is a nice
|
|
# fallback load balancer.
|
|
args.append('-l')
|
|
args.append('%d' % num_cores)
|
|
|
|
print ' '.join(args)
|