text: # 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
  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]
    elif arg.startswith('-C'):
      # Support -Cout/Default
      output_dir = arg[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))
  
  print ' '.join(args)
  