gyp performance: Add a DoMain version of build/compiler_version

build/compiler_version.py

 #!/usr/bin/env python
 # Copyright (c) 2012 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.
 
 """Compiler version checking tool for gcc
 
 Print gcc version as XY if you are running gcc X.Y.*.
 This is used to tweak build flags for gcc 4.4.
 """
 
 import os
 import re
 import subprocess
 import sys
 
+compiler_version_cache = {} # Map from (compiler, tool) -> version.

[scottmg, 2014/04/15 18:29:02]

nit; two blank lines between top level things in python (in chromium, sigh)

[scottmg, 2014/04/15 18:29:02]

nit; two spaces after code before #

 
 def GetVersion(compiler, tool):
   tool_output = tool_error = None
+  cache_key = (compiler, tool)
+  cached_version = compiler_version_cache.get(cache_key)

[scottmg, 2014/04/15 18:29:02]

is it the cache (not-invoking-compiler) or the not-invoking-python that helps
here?

[Daniel Bratell, 2014/04/15 19:37:41]

A bit hard to say because the python profiler doesn't correctly time external
processes. I did some simple measurements and I would say that about 400 ms is
the external -> DoMain conversion and 200 ms is the internal cache. Left is 13
ms + the part that the profiler doesn't catch, probably just a few ms.

+  if cached_version:
+    return cached_version
   try:
     # Note that compiler could be something tricky like "distcc g++".
     if tool == "compiler":
       compiler = compiler + " -dumpversion"
       # 4.6
       version_re = re.compile(r"(\d+)\.(\d+)")
     elif tool == "assembler":
       compiler = compiler + " -Xassembler --version -x assembler -c /dev/null"
       # Unmodified: GNU assembler (GNU Binutils) 2.24
       # Ubuntu: GNU assembler (GNU Binutils for Ubuntu) 2.22
       # Fedora: GNU assembler version 2.23.2
       version_re = re.compile(r"^GNU [^ ]+ .* (\d+).(\d+).*?$", re.M)
     elif tool == "linker":
       compiler = compiler + " -Xlinker --version"
       # Using BFD linker
       # Unmodified: GNU ld (GNU Binutils) 2.24
       # Ubuntu: GNU ld (GNU Binutils for Ubuntu) 2.22
       # Fedora: GNU ld version 2.23.2
       # Using Gold linker
       # Unmodified: GNU gold (GNU Binutils 2.24) 1.11
       # Ubuntu: GNU gold (GNU Binutils for Ubuntu 2.22) 1.11
       # Fedora: GNU gold (version 2.23.2) 1.11
       version_re = re.compile(r"^GNU [^ ]+ .* (\d+).(\d+).*?$", re.M)
     else:
       raise Exception("Unknown tool %s" % tool)
 
-    pipe = subprocess.Popen(compiler, shell=True,
+    # Force the locale to C otherwise the version string could be localized
+    # making regex matching fail.
+    env = os.environ.copy()
+    env["LC_ALL"] = "C"
+    pipe = subprocess.Popen(compiler, shell=True, env=env,
                             stdout=subprocess.PIPE, stderr=subprocess.PIPE)
     tool_output, tool_error = pipe.communicate()
     if pipe.returncode:
       raise subprocess.CalledProcessError(pipe.returncode, compiler)
 
-    result = version_re.match(tool_output)
-    return result.group(1) + result.group(2)
+    parsed_output = version_re.match(tool_output)
+    result = parsed_output.group(1) + parsed_output.group(2)
+    compiler_version_cache[cache_key] = result
+    return result
   except Exception, e:
     if tool_error:
       sys.stderr.write(tool_error)
     print >> sys.stderr, "compiler_version.py failed to execute:", compiler
     print >> sys.stderr, e
     return ""
 
 
 def main(args):
-  # Force the locale to C otherwise the version string could be localized
-  # making regex matching fail.
-  os.environ["LC_ALL"] = "C"
+  (ret_code, result) = ExtractVersion(args)

[scottmg, 2014/04/15 18:29:02]

no parens around return value

+  if ret_code == 0:
+    print(result)

[scottmg, 2014/04/15 18:29:02]

no parens around print (as this file doesn't seem to use them generally)

+  return ret_code
 
+def DoMain(args):
+  """Hook to be called from gyp withing starting a separate python

[scottmg, 2014/04/15 18:29:02]

withing -> without

+  interpreter."""
+  (ret_code, result) = ExtractVersion(args)

[scottmg, 2014/04/15 18:29:02]

no parens on return

+  if ret_code == 0:
+    return result
+  raise Exception("Failed to extract compiler version for args: %s" % args)
+
+def ExtractVersion(args):
   tool = "compiler"
   if len(args) == 1:
     tool = args[0]
   elif len(args) > 1:
     print "Unknown arguments!"
 
   # Check if CXX environment variable exists and
   # if it does use that compiler.
   cxx = os.getenv("CXX", None)

[scottmg, 2014/04/15 18:29:02]

change None to "g++" and delete the if/else

(I know this isn't part of your change, but it's just silly)

   if cxx:
     cxxversion = GetVersion(cxx, tool)
     if cxxversion != "":
-      print cxxversion
-      return 0
+      return (0, cxxversion)
   else:
     # Otherwise we check the g++ version.
     gccversion = GetVersion("g++", tool)
     if gccversion != "":
-      print gccversion
-      return 0
+      return (0, gccversion)
 
-  return 1
+  return (1, None)
 
 
 if __name__ == "__main__":
   sys.exit(main(sys.argv[1:]))