[GR-52561] [GR-51456] [GR-52646] Implement C API symbol cache using an array.

PullRequest: graalpython/3236

Author: fangerer

graalpython/com.oracle.graal.python.test/src/com/oracle/graal/python/test/builtin/objects/cext/CExtContextTest.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2022, 2023, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2022, 2024, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * The Universal Permissive License (UPL), Version 1.0
@@ -84,11 +84,6 @@ public TestCExtContext(PythonContext context, Object llvmLibrary) {
             super(context, llvmLibrary, false);
         }
 
-        @Override
-        protected Store initializeSymbolCache() {
-            throw new RuntimeException("should not reach here");
-        }
-
         public static TruffleString getBN(TruffleString s) {
             return getBaseName(s);
         }

graalpython/com.oracle.graal.python.test/src/tests/unittest_tags/test_concurrent_futures.txt

@@ -73,7 +73,6 @@
 *test.test_concurrent_futures.test_shutdown.ProcessPoolSpawnProcessPoolShutdownTest.test_processes_terminate
 *test.test_concurrent_futures.test_shutdown.ProcessPoolSpawnProcessPoolShutdownTest.test_run_after_shutdown
 *test.test_concurrent_futures.test_shutdown.ProcessPoolSpawnProcessPoolShutdownTest.test_shutdown_no_wait
-*test.test_concurrent_futures.test_shutdown.ProcessPoolSpawnProcessPoolShutdownTest.test_submit_after_interpreter_shutdown
 *test.test_concurrent_futures.test_shutdown.ThreadPoolShutdownTest.test_cancel_futures
 *test.test_concurrent_futures.test_shutdown.ThreadPoolShutdownTest.test_context_manager_shutdown
 *test.test_concurrent_futures.test_thread_pool.ThreadPoolExecutorTest.test_default_workers

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/PythonLanguage.java

@@ -364,9 +364,6 @@ public boolean isSingleContext() {
     @CompilationFinal(dimensions = 1) private volatile Object[] engineOptionsStorage;
     @CompilationFinal private volatile OptionValues engineOptions;
 
-    /** A shared shape for the C symbol cache (lazily initialized). */
-    private Shape cApiSymbolCache;
-
     /** For fast access to the PythonThreadState object by the owning thread. */
     private final ContextThreadLocal<PythonThreadState> threadState = locals.createContextThreadLocal(PythonContext.PythonThreadState::new);
 
@@ -984,17 +981,6 @@ public Shape getBuiltinTypeInstanceShape(PythonBuiltinClassType type) {
         return shape;
     }
 
-    /**
-     * Returns the shape used for the C API symbol cache.
-     */
-    @TruffleBoundary
-    public synchronized Shape getCApiSymbolCacheShape() {
-        if (cApiSymbolCache == null) {
-            cApiSymbolCache = Shape.newBuilder().build();
-        }
-        return cApiSymbolCache;
-    }
-
     /**
      * Cache call targets that are created for every new context, based on a single key.
      */

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/modules/cext/PythonCextTypeBuiltins.java

@@ -79,7 +79,6 @@
 import com.oracle.graal.python.builtins.objects.cext.capi.ExternalFunctionNodes.SetterRoot;
 import com.oracle.graal.python.builtins.objects.cext.common.CArrayWrappers.CArrayWrapper;
 import com.oracle.graal.python.builtins.objects.cext.common.CExtContext;
-import com.oracle.graal.python.builtins.objects.cext.common.CExtContext.Store;
 import com.oracle.graal.python.builtins.objects.common.DynamicObjectStorage;
 import com.oracle.graal.python.builtins.objects.dict.PDict;
 import com.oracle.graal.python.builtins.objects.function.PBuiltinFunction;
@@ -120,6 +119,8 @@
 import com.oracle.truffle.api.library.CachedLibrary;
 import com.oracle.truffle.api.nodes.Node;
 import com.oracle.truffle.api.nodes.RootNode;
+import com.oracle.truffle.api.object.DynamicObject;
+import com.oracle.truffle.api.object.Shape;
 import com.oracle.truffle.api.profiles.InlinedExactClassProfile;
 import com.oracle.truffle.api.strings.TruffleString;
 import com.oracle.truffle.api.utilities.CyclicAssumption;
@@ -164,14 +165,20 @@ static Object doIt(PythonNativeClass self, TruffleString className) {
         }
     }
 
+    static final class NativeTypeDictStorage extends DynamicObject {
+        public NativeTypeDictStorage(Shape shape) {
+            super(shape);
+        }
+    }
+
     @CApiBuiltin(ret = PyObjectTransfer, args = {PyTypeObject}, call = Ignored)
     abstract static class PyTruffle_NewTypeDict extends CApiUnaryBuiltinNode {
 
         @Specialization
         @TruffleBoundary
         static PDict doGeneric(PythonNativeClass nativeClass) {
             PythonLanguage language = PythonLanguage.get(null);
-            Store nativeTypeStore = new Store(language.getEmptyShape());
+            NativeTypeDictStorage nativeTypeStore = new NativeTypeDictStorage(language.getEmptyShape());
             PDict dict = PythonObjectFactory.getUncached().createDict(new DynamicObjectStorage(nativeTypeStore));
             HiddenAttr.WriteNode.executeUncached(dict, HiddenAttr.INSTANCESHAPE, language.getShapeForClass(nativeClass));
             return dict;

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/objects/cext/capi/CApiContext.java

@@ -48,6 +48,7 @@
 
 import java.io.IOException;
 import java.io.PrintStream;
+import java.lang.invoke.VarHandle;
 import java.nio.file.LinkOption;
 import java.util.ArrayList;
 import java.util.Arrays;
@@ -62,6 +63,7 @@
 
 import org.graalvm.collections.EconomicMap;
 import org.graalvm.collections.Pair;
+import org.graalvm.nativeimage.ImageInfo;
 
 import com.oracle.graal.python.PythonLanguage;
 import com.oracle.graal.python.builtins.PythonBuiltinClassType;
@@ -126,8 +128,6 @@
 import com.oracle.truffle.api.library.ExportLibrary;
 import com.oracle.truffle.api.library.ExportMessage;
 import com.oracle.truffle.api.nodes.Node;
-import com.oracle.truffle.api.object.DynamicObjectLibrary;
-import com.oracle.truffle.api.object.Shape;
 import com.oracle.truffle.api.source.Source;
 import com.oracle.truffle.api.source.Source.SourceBuilder;
 import com.oracle.truffle.api.strings.TruffleString;
@@ -201,6 +201,18 @@ public final class CApiContext extends CExtContext {
     public Object timezoneType;
     private PyCapsule pyDateTimeCAPICapsule;
 
+    /**
+     * Same as {@link #nativeSymbolCache} if there is only one context per JVM (i.e. just one engine
+     * in single-context mode). Will be {@code null} in case of multiple contexts.
+     */
+    @CompilationFinal(dimensions = 1) private static Object[] nativeSymbolCacheSingleContext;
+    private static boolean nativeSymbolCacheSingleContextUsed;
+
+    /**
+     * A private (i.e. per-context) cache of C API symbols (usually helper functions).
+     */
+    private final Object[] nativeSymbolCache;
+
     private record ClosureInfo(Object closure, Object delegate, Object executable, long pointer) {
     }
 
@@ -239,6 +251,37 @@ public static TruffleLogger getLogger(Class<?> clazz) {
 
     public CApiContext(PythonContext context, Object llvmLibrary, boolean useNativeBackend) {
         super(context, llvmLibrary, useNativeBackend);
+        this.nativeSymbolCache = new Object[NativeCAPISymbol.values().length];
+
+        /*
+         * Publish the native symbol cache to the static field if following is given: (1) The static
+         * field hasn't been used by another instance yet (i.e. '!used'), and (2) we are in
+         * single-context mode. This initialization ensures that if
+         * 'CApiContext.nativeSymbolCacheSingleContext != null', the context is safe to use it and
+         * just needs to do a null check.
+         */
+        synchronized (CApiContext.class) {
+            if (!CApiContext.nativeSymbolCacheSingleContextUsed && context.getLanguage().isSingleContext()) {
+                assert CApiContext.nativeSymbolCacheSingleContext == null;
+
+                // we cannot be in built-time code because this is using pre-initialized contexts
+                assert !ImageInfo.inImageBuildtimeCode();
+
+                // this is the first context accessing the static symbol cache
+                CApiContext.nativeSymbolCacheSingleContext = this.nativeSymbolCache;
+            } else if (CApiContext.nativeSymbolCacheSingleContext != null) {
+                assert CApiContext.nativeSymbolCacheSingleContextUsed;
+                /*
+                 * In this case, this context instance is at least the second one attempting to use
+                 * the static symbol cache. We now clear the static field to indicate that every
+                 * context instance should use its private cache. If a former context already used
+                 * the cache and there is already compiled code, it is not necessary to invalidate
+                 * the code because the cache is still valid.
+                 */
+                CApiContext.nativeSymbolCacheSingleContext = null;
+            }
+            CApiContext.nativeSymbolCacheSingleContextUsed = true;
+        }
 
         // initialize primitive native wrapper cache
         primitiveNativeWrapperCache = new PrimitiveNativeWrapper[262];
@@ -382,27 +425,59 @@ private void freeSmallInts() {
         }
     }
 
-    @TruffleBoundary
-    @Override
-    protected Store initializeSymbolCache() {
-        PythonLanguage language = getContext().getLanguage();
-        Shape symbolCacheShape = language.getCApiSymbolCacheShape();
-        // We will always get an empty shape from the language and we do always add same key-value
-        // pairs (in the same order). So, in the end, each context should get the same shape.
-        Store s = new Store(symbolCacheShape);
-        for (NativeCAPISymbol sym : NativeCAPISymbol.getValues()) {
-            DynamicObjectLibrary.getUncached().put(s, sym, PNone.NO_VALUE);
-        }
-        return s;
-    }
-
     public Object getModuleByIndex(int i) {
         if (i < modulesByIndex.size()) {
             return modulesByIndex.get(i);
         }
         return null;
     }
 
+    /**
+     * Retrieves the C API symbol cache instance in the fastest possible way. If there is just one
+     * instance of {@link CApiContext}, it will load the cache stored from the static field
+     * {@link CApiContext#nativeSymbolCacheSingleContext}. Otherwise, it will load the cache from
+     * the instance field {@link CApiContext#nativeSymbolCache}.
+     * 
+     * @param caller The requesting node (may be {@code null}). Used for the fast-path lookup of the
+     *            {@link CApiContext} instance (if necessary).
+     * @return The C API symbol cache.
+     */
+    private static Object[] getSymbolCache(Node caller) {
+        Object[] nativeSymbolCacheSingleContext = CApiContext.nativeSymbolCacheSingleContext;
+        if (nativeSymbolCacheSingleContext != null) {
+            return nativeSymbolCacheSingleContext;
+        }
+        return PythonContext.get(caller).getCApiContext().nativeSymbolCache;
+    }
+
+    public static Object getNativeSymbol(Node caller, NativeCAPISymbol symbol) {
+        Object[] nativeSymbolCache = getSymbolCache(caller);
+        Object result = nativeSymbolCache[symbol.ordinal()];
+        if (result == null) {
+            CompilerDirectives.transferToInterpreterAndInvalidate();
+            result = lookupNativeSymbol(nativeSymbolCache, symbol);
+        }
+        assert result != null;
+        return result;
+    }
+
+    /**
+     * Lookup the given C API symbol in the library, store it to the provided cache, and return the
+     * callable symbol.
+     */
+    private static Object lookupNativeSymbol(Object[] nativeSymbolCache, NativeCAPISymbol symbol) {
+        CompilerAsserts.neverPartOfCompilation();
+        String name = symbol.getName();
+        try {
+            Object nativeSymbol = InteropLibrary.getUncached().readMember(PythonContext.get(null).getCApiContext().getLLVMLibrary(), name);
+            nativeSymbol = CExtContext.ensureExecutable(nativeSymbol, symbol);
+            VarHandle.storeStoreFence();
+            return nativeSymbolCache[symbol.ordinal()] = nativeSymbol;
+        } catch (UnsupportedMessageException | UnknownIdentifierException e) {
+            throw CompilerDirectives.shouldNotReachHere(e);
+        }
+    }
+
     @TruffleBoundary
     public AllocInfo traceFree(Object ptr, @SuppressWarnings("unused") PFrame.Reference curFrame, @SuppressWarnings("unused") TruffleString clazzName) {
         if (allocatedNativeMemory == null) {
@@ -746,6 +821,17 @@ public void finalizeCapi() {
         for (Object pyMethodDefPointer : methodDefinitions.values()) {
             PyMethodDefHelper.free(pyMethodDefPointer);
         }
+        /*
+         * If the static symbol cache is not null, then it is guaranteed that this context instance
+         * was the exclusive user of it. We can now reset the state such that other contexts created
+         * after this can use it.
+         */
+        synchronized (CApiContext.class) {
+            if (CApiContext.nativeSymbolCacheSingleContext != null) {
+                CApiContext.nativeSymbolCacheSingleContext = null;
+                CApiContext.nativeSymbolCacheSingleContextUsed = false;
+            }
+        }
     }
 
     @TruffleBoundary