Call setlocale() only once per RubyLanguage instance

* Ideally it would be once per process and done in the launcher but that
  is difficult because we do not know the ruby home in the launcher before
  creating the RubyContext and setting the locale late seems more risky.
  We also need setlocale(LC_CTYPE, "") when run not from the launcher.
* When run from the launcher (!embedded) there is only a single RubyLanguage
  so we setlocale() once per process.
* If embedded we run setlocale(LC_CTYPE, "") once per RubyLanguage instance.

Author: eregon

src/main/java/org/truffleruby/RubyLanguage.java

@@ -39,6 +39,8 @@
 import com.oracle.truffle.api.strings.AbstractTruffleString;
 import com.oracle.truffle.api.strings.InternalByteArray;
 import com.oracle.truffle.api.strings.TruffleString;
+import org.graalvm.nativeimage.ImageInfo;
+import org.graalvm.nativeimage.ProcessProperties;
 import org.graalvm.options.OptionDescriptors;
 import org.prism.Parser;
 import org.truffleruby.annotations.SuppressFBWarnings;
@@ -125,6 +127,7 @@
 import org.truffleruby.shared.Metrics;
 import org.truffleruby.shared.TruffleRuby;
 import org.truffleruby.shared.options.OptionsCatalog;
+import org.truffleruby.signal.LibRubySignal;
 import org.truffleruby.stdlib.CoverageManager;
 
 import com.oracle.truffle.api.Assumption;
@@ -458,6 +461,7 @@ public RubyContext createContext(Env env) {
                 this.allocationReporter = env.lookup(AllocationReporter.class);
                 this.options = new LanguageOptions(env, env.getOptions(), singleContext);
                 setRubyHome(findRubyHome(env));
+                setupLocale(env, rubyHome);
                 loadLibYARPBindings();
                 this.coreLoadPath = buildCoreLoadPath(this.options.CORE_LOAD_PATH);
                 this.corePath = coreLoadPath + File.separator + "core" + File.separator;
@@ -539,6 +543,7 @@ protected boolean patchContext(RubyContext context, Env newEnv) {
 
         synchronized (this) {
             setRubyHome(findRubyHome(newEnv));
+            setupLocale(newEnv, rubyHome);
             loadLibYARPBindings();
             setupCleaner();
         }
@@ -819,6 +824,24 @@ private boolean isRubyHome(TruffleFile path) {
                 lib.resolve("patches").isDirectory();
     }
 
+    private void setupLocale(Env env, String rubyHome) {
+        // CRuby does setlocale(LC_CTYPE, "") because this is needed to get the locale encoding with nl_langinfo(CODESET).
+        // This means every locale category except LC_CTYPE remains the initial "C".
+        // LC_CTYPE is set according to environment variables (LC_ALL, LC_CTYPE, LANG).
+        // HotSpot does setlocale(LC_ALL, "") and Native Image does nothing.
+        // We match CRuby by doing setlocale(LC_ALL, "C") and setlocale(LC_CTYPE, "").
+        // This also affects C functions that depend on the locale in C extensions, so best to follow CRuby here.
+        // Change the strict minimum if embedded because setlocale() is process-wide.
+        if (env.getOptions().get(OptionsCatalog.EMBEDDED_KEY)) {
+            if (ImageInfo.inImageRuntimeCode()) {
+                ProcessProperties.setLocale("LC_CTYPE", "");
+            }
+        } else {
+            LibRubySignal.loadLibrary(rubyHome, Platform.LIB_SUFFIX);
+            LibRubySignal.setupLocale();
+        }
+    }
+
     private void loadLibYARPBindings() {
         String libyarpbindings = getRubyHome() + "/lib/libyarpbindings" + Platform.LIB_SUFFIX;
         Parser.loadLibrary(libyarpbindings);

src/main/java/org/truffleruby/core/DataObjectFinalizationService.java

@@ -71,6 +71,7 @@ public DataObjectFinalizationService(RubyLanguage language, ReferenceProcessor r
         this(language, referenceProcessor.processingQueue);
     }
 
+    @TruffleBoundary
     public DataObjectFinalizerReference addFinalizer(RubyContext context, Object object, Object finalizerCFunction,
             Object dataStruct) {
         final DataObjectFinalizerReference newRef = createRef(object, finalizerCFunction, dataStruct);

src/main/java/org/truffleruby/core/ReferenceProcessingService.java

@@ -78,6 +78,7 @@ public ReferenceProcessor(RubyContext context) {
             this.context = context;
         }
 
+        @TruffleBoundary
         void processReferenceQueue(ReferenceProcessingService<?, ?> service) {
             if (processOnMainThread()) {
                 drainReferenceQueues();

src/main/java/org/truffleruby/core/encoding/EncodingManager.java

@@ -20,10 +20,8 @@
 import java.util.concurrent.ConcurrentHashMap;
 
 import com.oracle.truffle.api.CompilerDirectives;
-import com.oracle.truffle.api.TruffleOptions;
 import com.oracle.truffle.api.interop.InteropException;
 import com.oracle.truffle.api.interop.InteropLibrary;
-import org.graalvm.nativeimage.ProcessProperties;
 import org.graalvm.shadowed.org.jcodings.Encoding;
 import org.graalvm.shadowed.org.jcodings.EncodingDB;
 import org.truffleruby.RubyContext;
@@ -39,8 +37,6 @@
 
 import com.oracle.truffle.api.CompilerDirectives.CompilationFinal;
 import com.oracle.truffle.api.CompilerDirectives.TruffleBoundary;
-import org.truffleruby.shared.Platform;
-import org.truffleruby.signal.LibRubySignal;
 
 import static org.truffleruby.core.encoding.Encodings.INITIAL_NUMBER_OF_ENCODINGS;
 
@@ -131,27 +127,12 @@ public void initializeDefaultEncodings(TruffleNFIPlatform nfi, NativeConfigurati
     }
 
     private void initializeLocaleEncoding(TruffleNFIPlatform nfi, NativeConfiguration nativeConfiguration) {
-        // CRuby does setlocale(LC_CTYPE, "") because this is needed to get the locale encoding with nl_langinfo(CODESET).
-        // This means every locale category except LC_CTYPE remains the initial "C".
-        // LC_CTYPE is set according to environment variables (LC_ALL, LC_CTYPE, LANG).
-        // HotSpot does setlocale(LC_ALL, "") and Native Image does nothing.
-        // We match CRuby by doing setlocale(LC_ALL, "C") and setlocale(LC_CTYPE, "").
-        // This also affects C functions that depend on the locale in C extensions, so best to follow CRuby here.
-        // Change the strict minimum if embedded because setlocale() is process-wide.
-        if (context.getOptions().EMBEDDED) {
-            if (TruffleOptions.AOT) {
-                ProcessProperties.setLocale("LC_CTYPE", "");
-            }
-        } else {
-            LibRubySignal.loadLibrary(language.getRubyHome(), Platform.LIB_SUFFIX);
-            LibRubySignal.setupLocale();
-        }
-
         final String localeEncodingName;
         final String detector;
         if (nfi != null) {
             final int codeset = (int) nativeConfiguration.get("platform.langinfo.CODESET");
 
+            // nl_langinfo() needs setlocale(LC_CTYPE, "") before, which is done in RubyLanguage#setupLocale()
             // char *nl_langinfo(nl_item item);
             // nl_item is int on at least Linux and macOS
             final Object nl_langinfo = nfi.getFunction(context, "nl_langinfo", "(sint32):string");

src/options.yml

@@ -48,6 +48,7 @@ LANGUAGE_OPTIONS:
 - CLASS_CACHE
 - ARRAY_DUP_CACHE
 - ARRAY_STRATEGY_CACHE
+# Other
 - EXPERIMENTAL_ENGINE_CACHING
 - RUN_TWICE
 - CHECK_CLONE_UNINITIALIZED_CORRECTNESS
@@ -85,6 +86,8 @@ EXPERT:
     LAZY_RUBYGEMS: [lazy-rubygems, boolean, ['RUBYGEMS && ', DEFAULT_LAZY], Load RubyGems lazily on first failing require]
 
     # Embedding options
+    # It would be tempting to make these language options, but that does not work because the pre-initialized context is created with (isNativeAccessAllowed=false, embedded=true)
+    # and it must be compatible (to be reused) with the runtime context created from the truffleruby launcher, which is (isNativeAccessAllowed=true, embedded=false).
     EMBEDDED: [embedded, boolean, true, 'Set default options for an embedded use of TruffleRuby, rather than top-level use']
     NATIVE_PLATFORM: [platform-native, boolean, ['env.isNativeAccessAllowed() && ', true], Enables native calls via Truffle NFI for internal functionality]
     NATIVE_INTERRUPT: [platform-native-interrupt, boolean, NATIVE_PLATFORM, Use the SIGVTALRM signal to interrupt native blocking calls]