[libcxx][dsl] Cache the result of compilerMacros()

[arichardson]

Summary

This function is called about 80 times during test startup and most of
the invokes the same compiler command. Avoiding running a new process and
parsing the output into a python dict by caching the output. This
noticeably speeds up running a single lit test: for me this patch changes
the time it takes to run lit with --no-execute for a single test from
~7 seconds to ~5.5 seconds.

[ldionne]

Thanks for opening these reviews. I proposed a unified approach to solve this problem in https://reviews.llvm.org/D89003, please let me know what you think.

[arichardson]

Better solution (D89003) has been committed.

libcxx/utils/libcxx/test/dsl.py

def compilerMacros(config, flags=''):
   Return a dictionary of predefined compiler macros.
 
   The keys are strings representing macros, and the values are strings
   representing what each macro is defined to.
 
   If the optional `flags` argument (a string) is provided, these flags will
   be added to the compiler invocation when generating the macros.
   """
+  # Since this function is called many times, we cache the output of the compiler macros
+  # for a given command line.
+  # Note: ideally we would cache this based on the full command line, but we don't know it
+  # in this function, so we use the flags argument + the configured substitutions as the
+  # equivalent of the resulting command line.
+  cache = getattr(config, "_cached_macros", None)
+  # Changes in substitutions should also invalidate the cache since they could affect
+  # the commandline used to dump macros.
+  cached_subs = tuple(config.substitutions)  # Needs to be a hashable type, list won't work
+  if cache is not None:
+    result = cache.get((flags, cached_subs), None)
+    if result is not None:
+      return result
   with _makeConfigTest(config) as test:
     unparsedOutput, err, exitCode, timeoutInfo = _executeScriptInternal(test, [
       "%{{cxx}} -xc++ {} -dM -E %{{flags}} %{{compile_flags}} {}".format(os.devnull, flags)
     ])
     parsedMacros = dict()
     defines = (l.strip() for l in unparsedOutput.split('\n') if l.startswith('#define '))
     for line in defines:
       line = line[len('#define '):]
       macro, _, value = line.partition(' ')
       parsedMacros[macro] = value
-    return parsedMacros
+  if not hasattr(config, "_cached_macros"):
+    config._cached_macros = {(flags, cached_subs): parsedMacros}
+  else:
+    config._cached_macros[(flags, cached_subs)] = parsedMacros
 
 def featureTestMacros(config, flags=''):
   """
   Return a dictionary of feature test macros.
 
   The keys are strings representing feature test macros, and the values are
   integers representing the value of the macro.
   """