[libc++][dsl] Run checks for locale names aliases using a single %exec

[arichardson]

Summary

This changes the checking for available locales to use one program that
iterates over argv to test multiple locale names instead of checking each
name with a separate executable.

This massively speeds up running individual tests using an SSH executor
(it can take up to 10 seconds to compile and run a single test in some
emulated environments) in case no locales are installed since then all
fallback names are tested idividually. But even on a native machine
this reduces the libc++ lit startup time by ~1-2 second for me on a machine
that does not have locale data installed.

[ldionne]

Generally looks good to me, with suggestion. I agree it's more clever to check things this way.

libcxx/utils/libcxx/test/dsl.py

153

Could we simply change this to hasAnyLocale(config, locales), and then you pass a list of all the alts below?

[arichardson]

libcxx/utils/libcxx/test/dsl.py

153

Yes definitely, I only had the name included for debugging and didn't remove it.

[arichardson]

drop unnecessary argument

[ldionne]

Thanks! This is going to be a lot better on SSH executors.

[ldionne]

Hmm, actually, did you run the tests? I would assume at least the libcxx/test/libcxx/selftest/dsl needs updating?

[arichardson]

In D88884#2321946, @ldionne wrote:

Hmm, actually, did you run the tests? I would assume at least the libcxx/test/libcxx/selftest/dsl needs updating?

Sorry, I only ran the std/ tests. Will fix asap.

[arichardson]

Fix tests

[ldionne]

libcxx/test/libcxx/selftest/dsl/dsl.sh.py

218

['en_US.UTF-8']

[ldionne]

LGTM with that fix. Please fix and commit.

libcxx/test/libcxx/selftest/dsl/dsl.sh.py

 class TestHasLocale(SetupConfigs):
     """
     Tests for libcxx.test.dsl.hasLocale
     """
     def test_doesnt_explode(self):
         # It's really hard to test that a system has a given locale, so at least
         # make sure we don't explode when we try to check it.
         try:
-            dsl.hasLocale(self.config, 'en_US.UTF-8')
+            dsl.hasAnyLocale(self.config, ['en_US.UTF-8'])
         except subprocess.CalledProcessError:
             self.fail("checking for hasLocale should not explode")
 
     def test_nonexistent_locale(self):
-        self.assertFalse(dsl.hasLocale(self.config, 'for_sure_this_is_not_an_existing_locale'))
+        self.assertFalse(dsl.hasAnyLocale(self.config, ['for_sure_this_is_not_an_existing_locale']))
 
 
 class TestCompilerMacros(SetupConfigs):
     """
     Tests for libcxx.test.dsl.compilerMacros
     """
     def test_basic(self):
         macros = dsl.compilerMacros(self.config)

libcxx/utils/libcxx/test/dsl.py

def hasCompileFlag(config, flag):
   """
   with _makeConfigTest(config) as test:
     out, err, exitCode, timeoutInfo = _executeScriptInternal(test, [
       "%{{cxx}} -xc++ {} -Werror -fsyntax-only %{{flags}} %{{compile_flags}} {}".format(os.devnull, flag)
     ])
     return exitCode == 0
 
 @_memoizeExpensiveOperation(lambda c, l: (c.substitutions, c.environment, l))
-def hasLocale(config, locale):
+def hasAnyLocale(config, locales):
   """
   Return whether the runtime execution environment supports a given locale.
+  Different systems may use different names for a locale, so this function checks
+  whether any of the passed locale names is supported by setlocale() and returns
+  true if one of them works.
 
   This is done by executing a program that tries to set the given locale using
   %{exec} -- this means that the command may be executed on a remote host
   depending on the %{exec} substitution.
   """
   program = """
     #include <locale.h>
-    int main(int, char** argv) {
-      if (::setlocale(LC_ALL, argv[1]) != NULL) return 0;
-      else                                      return 1;
+    #include <stdio.h>
+    int main(int argc, char** argv) {
+      // For debugging purposes print which locales are (not) supported.
+      for (int i = 1; i < argc; i++) {
+        if (::setlocale(LC_ALL, argv[i]) != NULL) {
+          printf("%s is supported.\\n", argv[i]);
+          return 0;
+        }
+        printf("%s is not supported.\\n", argv[i]);
+      }
+      return 1;
     }
   """
-  return programOutput(config, program, args=[pipes.quote(locale)],
-                       testPrefix="check_locale_" + locale) is not None
+  return programOutput(config, program, args=[pipes.quote(l) for l in locales],
+                       testPrefix="check_locale_" + locales[0]) is not None
 
 @_memoizeExpensiveOperation(lambda c, flags='': (c.substitutions, c.environment, flags))
 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.

libcxx/utils/libcxx/test/features.py

locales = {
   'zh_CN.UTF-8':     ['zh_CN.UTF-8', 'zh_CN.utf8', 'Chinese_China.936'],
   'fr_CA.ISO8859-1': ['fr_CA.ISO8859-1', 'French_Canada.1252'],
   'cs_CZ.ISO8859-2': ['cs_CZ.ISO8859-2', 'Czech_Czech Republic.1250']
 }
 for locale, alts in locales.items():
   # Note: Using alts directly in the lambda body here will bind it to the value at the
   # end of the loop. Assigning it to a default argument works around this issue.
   DEFAULT_FEATURES.append(Feature(name='locale.{}'.format(locale),
-                                  when=lambda cfg, alts=alts: any(hasLocale(cfg, alt) for alt in alts)))
+                                  when=lambda cfg, alts=alts: hasAnyLocale(cfg, alts)))
 
 
 # Add features representing the platform name: darwin, linux, windows, etc...
 DEFAULT_FEATURES += [
   Feature(name='darwin', when=lambda cfg: '__APPLE__' in compilerMacros(cfg)),
   Feature(name='windows', when=lambda cfg: '_WIN32' in compilerMacros(cfg)),
   Feature(name='linux', when=lambda cfg: '__linux__' in compilerMacros(cfg)),
   Feature(name='netbsd', when=lambda cfg: '__NetBSD__' in compilerMacros(cfg))
 ]