[GR-31824] [GR-31872] Bulk release shared finalizers rather than queueing many shared actions

PullRequest: graalpython/1828

Author: timfel

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/modules/GraalPythonModuleBuiltins.java

@@ -45,6 +45,7 @@
 import static com.oracle.graal.python.runtime.exception.PythonErrorType.ImportError;
 import static com.oracle.graal.python.runtime.exception.PythonErrorType.NotImplementedError;
 
+import java.io.IOException;
 import java.io.PrintWriter;
 import java.util.List;
 import java.util.logging.Level;
@@ -196,6 +197,13 @@ public void postInitialize(Python3Core core) {
         PList executableList = PythonObjectFactory.getUncached().createList(arr);
         mod.setAttribute("executable_list", executableList);
         mod.setAttribute("ForeignType", core.lookupType(PythonBuiltinClassType.ForeignObject));
+
+        if (!context.getOption(PythonOptions.EnableDebuggingBuiltins)) {
+            mod.setAttribute("dump_truffle_ast", PNone.NO_VALUE);
+            mod.setAttribute("tdebug", PNone.NO_VALUE);
+            mod.setAttribute("set_storage_strategy", PNone.NO_VALUE);
+            mod.setAttribute("dump_heap", PNone.NO_VALUE);
+        }
     }
 
     private static Object[] convertToObjectArray(String[] arr) {
@@ -683,4 +691,21 @@ Object doIt(Object value) {
         }
     }
 
+    @Builtin(name = "dump_heap", minNumOfPositionalArgs = 0)
+    @GenerateNodeFactory
+    abstract static class DumpHeapNode extends PythonBuiltinNode {
+        @Specialization
+        String doit(VirtualFrame frame, @CachedContext(PythonLanguage.class) PythonContext context) {
+            TruffleFile tempFile;
+            try {
+                tempFile = context.getEnv().createTempFile(context.getEnv().getCurrentWorkingDirectory(), "graalpython", ".hprof");
+                tempFile.delete();
+            } catch (IOException e) {
+                throw raiseOSError(frame, e);
+            }
+            PythonUtils.dumpHeap(tempFile.getPath());
+            return tempFile.getPath();
+        }
+    }
+
 }

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/modules/ThreadModuleBuiltins.java

@@ -49,11 +49,13 @@
 import com.oracle.graal.python.PythonLanguage;
 import com.oracle.graal.python.builtins.Builtin;
 import com.oracle.graal.python.builtins.CoreFunctions;
+import com.oracle.graal.python.builtins.Python3Core;
 import com.oracle.graal.python.builtins.PythonBuiltinClassType;
 import com.oracle.graal.python.builtins.PythonBuiltins;
 import com.oracle.graal.python.builtins.objects.PNone;
 import com.oracle.graal.python.builtins.objects.exception.PBaseException;
 import com.oracle.graal.python.builtins.objects.function.PKeyword;
+import com.oracle.graal.python.builtins.objects.module.PythonModule;
 import com.oracle.graal.python.builtins.objects.thread.PLock;
 import com.oracle.graal.python.builtins.objects.thread.PRLock;
 import com.oracle.graal.python.builtins.objects.thread.PThread;
@@ -67,21 +69,26 @@
 import com.oracle.graal.python.nodes.function.builtins.PythonUnaryBuiltinNode;
 import com.oracle.graal.python.runtime.GilNode;
 import com.oracle.graal.python.runtime.PythonContext;
-import com.oracle.graal.python.builtins.Python3Core;
 import com.oracle.graal.python.runtime.exception.PException;
 import com.oracle.graal.python.runtime.exception.PythonThreadKillException;
 import com.oracle.truffle.api.CompilerDirectives.TruffleBoundary;
+import com.oracle.truffle.api.CompilerDirectives;
 import com.oracle.truffle.api.TruffleLanguage;
 import com.oracle.truffle.api.dsl.Cached;
 import com.oracle.truffle.api.dsl.CachedContext;
 import com.oracle.truffle.api.dsl.GenerateNodeFactory;
 import com.oracle.truffle.api.dsl.NodeFactory;
 import com.oracle.truffle.api.dsl.Specialization;
 import com.oracle.truffle.api.frame.VirtualFrame;
+import com.oracle.truffle.api.nodes.UnexpectedResultException;
+import com.oracle.truffle.api.object.DynamicObjectLibrary;
+import com.oracle.truffle.api.object.HiddenKey;
 import com.oracle.truffle.api.profiles.ConditionProfile;
 
 @CoreFunctions(defineModule = "_thread")
 public class ThreadModuleBuiltins extends PythonBuiltins {
+    private static final HiddenKey THREAD_COUNT = new HiddenKey("thread_count");
+
     @Override
     protected List<? extends NodeFactory<? extends PythonBuiltinBaseNode>> getNodeFactories() {
         return ThreadModuleBuiltinsFactory.getFactories();
@@ -91,6 +98,7 @@ protected List<? extends NodeFactory<? extends PythonBuiltinBaseNode>> getNodeFa
     public void initialize(Python3Core core) {
         builtinConstants.put("error", core.lookupType(PythonBuiltinClassType.RuntimeError));
         builtinConstants.put("TIMEOUT_MAX", TIMEOUT_MAX);
+        builtinConstants.put(THREAD_COUNT, 0);
         super.initialize(core);
     }
 
@@ -140,13 +148,17 @@ public static long getId() {
         }
     }
 
-    @Builtin(name = "_count", minNumOfPositionalArgs = 0)
+    @Builtin(name = "_count", minNumOfPositionalArgs = 1, declaresExplicitSelf = true)
     @GenerateNodeFactory
-    abstract static class GetThreadCountNode extends PythonBuiltinNode {
+    abstract static class GetThreadCountNode extends PythonUnaryBuiltinNode {
         @Specialization
         @TruffleBoundary
-        long getCount() {
-            return getContext().getThreadGroup().activeCount();
+        long getCount(PythonModule self) {
+            try {
+                return DynamicObjectLibrary.getUncached().getIntOrDefault(self, THREAD_COUNT, 0);
+            } catch (UnexpectedResultException e) {
+                throw CompilerDirectives.shouldNotReachHere();
+            }
         }
     }
 
@@ -189,6 +201,7 @@ long start(VirtualFrame frame, Object cls, Object callable, Object args, Object
                         @Cached ExpandKeywordStarargsNode getKwArgsNode) {
             PythonContext context = getContext();
             TruffleLanguage.Env env = context.getEnv();
+            PythonModule threadModule = context.getCore().lookupBuiltinModule("_thread");
 
             // TODO: python thread stack size != java thread stack size
             // ignore setting the stack size for the moment
@@ -197,11 +210,31 @@ long start(VirtualFrame frame, Object cls, Object callable, Object args, Object
                 PKeyword[] keywords = getKwArgsNode.execute(kwargs);
 
                 try (GilNode.UncachedAcquire gil = GilNode.uncachedAcquire()) {
-                    // n.b.: It is important to pass 'null' frame here because each thread has it's
-                    // own stack and if we would pass the current frame, this would be connected as
-                    // a caller which is incorrect. However, the thread-local 'topframeref' is
-                    // initialized with EMPTY which will be picked up.
-                    callNode.execute(null, callable, arguments, keywords);
+                    // the increment is protected by the gil
+                    DynamicObjectLibrary lib = DynamicObjectLibrary.getUncached();
+                    int curCount = 0;
+                    try {
+                        curCount = lib.getIntOrDefault(threadModule, THREAD_COUNT, 0);
+                    } catch (UnexpectedResultException ure) {
+                        throw CompilerDirectives.shouldNotReachHere();
+                    }
+                    lib.putInt(threadModule, THREAD_COUNT, curCount + 1);
+                    try {
+                        // n.b.: It is important to pass 'null' frame here because each thread has
+                        // it's own stack and if we would pass the current frame, this would be
+                        // connected as a caller which is incorrect. However, the thread-local
+                        // 'topframeref' is initialized with EMPTY which will be picked up.
+                        callNode.execute(null, callable, arguments, keywords);
+                    } finally {
+                        // the catch blocks run ofter the gil is released, so we decrement the
+                        // threadcount here while still protected by the gil
+                        try {
+                            curCount = lib.getIntOrDefault(threadModule, THREAD_COUNT, 1);
+                        } catch (UnexpectedResultException ure) {
+                            throw CompilerDirectives.shouldNotReachHere();
+                        }
+                        lib.putInt(threadModule, THREAD_COUNT, curCount - 1);
+                    }
                 } catch (PythonThreadKillException e) {
                     return;
                 } catch (PException e) {

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/nodes/call/special/CallBinaryMethodNode.java

@@ -347,7 +347,7 @@ Object callMethodSingleContext(VirtualFrame frame, @SuppressWarnings("unused") P
     @Specialization(guards = {"func == cachedFunc", "builtinNode != null", "takesSelfArg",
                     "frame != null || unusedFrame"}, limit = "getCallSiteInlineCacheMaxDepth()", assumptions = "singleContextAssumption()")
     Object callSelfMethodSingleContext(VirtualFrame frame, @SuppressWarnings("unused") PBuiltinMethod func, Object arg1, Object arg2,
-                    @SuppressWarnings("unused") @Cached("func") PBuiltinMethod cachedFunc,
+                    @SuppressWarnings("unused") @Cached(value = "func", weak = true) PBuiltinMethod cachedFunc,
                     @SuppressWarnings("unused") @Cached("takesSelfArg(func)") boolean takesSelfArg,
                     @Cached("getTernary(frame, func.getFunction())") PythonTernaryBuiltinNode builtinNode,
                     @SuppressWarnings("unused") @Cached("frameIsUnused(builtinNode)") boolean unusedFrame) {

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/nodes/call/special/CallQuaternaryMethodNode.java

@@ -81,7 +81,7 @@ Object call(VirtualFrame frame, @SuppressWarnings("unused") PBuiltinFunction fun
     @Specialization(guards = {"func == cachedFunc", "builtinNode != null", "!takesSelfArg",
                     "frame != null || unusedFrame"}, limit = "getCallSiteInlineCacheMaxDepth()", assumptions = "singleContextAssumption()")
     Object callMethodSingle(VirtualFrame frame, @SuppressWarnings("unused") PBuiltinMethod func, Object arg1, Object arg2, Object arg3, Object arg4,
-                    @SuppressWarnings("unused") @Cached("func") PBuiltinMethod cachedFunc,
+                    @SuppressWarnings("unused") @Cached(value = "func", weak = true) PBuiltinMethod cachedFunc,
                     @SuppressWarnings("unused") @Cached("takesSelfArg(func)") boolean takesSelfArg,
                     @Cached("getQuaternary(frame, func.getFunction())") PythonQuaternaryBuiltinNode builtinNode,
                     @SuppressWarnings("unused") @Cached("frameIsUnused(builtinNode)") boolean unusedFrame) {

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/nodes/call/special/CallTernaryMethodNode.java

@@ -211,7 +211,7 @@ static Object doBuiltinMethodCtCached(VirtualFrame frame, @SuppressWarnings("unu
     @Specialization(guards = {"func == cachedFunc", "builtinNode != null", "takesSelfArg",
                     "frame != null || unusedFrame"}, limit = "getCallSiteInlineCacheMaxDepth()", assumptions = "singleContextAssumption()")
     static Object callSelfMethodSingleContext(VirtualFrame frame, @SuppressWarnings("unused") PBuiltinMethod func, Object arg1, Object arg2, Object arg3,
-                    @SuppressWarnings("unused") @Cached("func") PBuiltinMethod cachedFunc,
+                    @SuppressWarnings("unused") @Cached(value = "func", weak = true) PBuiltinMethod cachedFunc,
                     @SuppressWarnings("unused") @Cached("takesSelfArg(func)") boolean takesSelfArg,
                     @Cached("getQuaternary(frame, func.getFunction())") PythonQuaternaryBuiltinNode builtinNode,
                     @SuppressWarnings("unused") @Cached("frameIsUnused(builtinNode)") boolean unusedFrame) {

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/nodes/call/special/CallUnaryMethodNode.java

@@ -225,7 +225,7 @@ Object callMethodSingleContext(VirtualFrame frame, @SuppressWarnings("unused") P
     @Specialization(guards = {"func == cachedFunc", "builtinNode != null", "takesSelfArg",
                     "frame != null || unusedFrame"}, limit = "getCallSiteInlineCacheMaxDepth()", assumptions = "singleContextAssumption()")
     Object callSelfMethodSingleContext(VirtualFrame frame, @SuppressWarnings("unused") PBuiltinMethod func, Object arg,
-                    @SuppressWarnings("unused") @Cached("func") PBuiltinMethod cachedFunc,
+                    @SuppressWarnings("unused") @Cached(value = "func", weak = true) PBuiltinMethod cachedFunc,
                     @SuppressWarnings("unused") @Cached("takesSelfArg(func)") boolean takesSelfArg,
                     @Cached("getBinary(frame, func.getFunction())") PythonBinaryBuiltinNode builtinNode,
                     @SuppressWarnings("unused") @Cached("frameIsUnused(builtinNode)") boolean unusedFrame) {

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/runtime/AsyncHandler.java

@@ -44,6 +44,7 @@
 import java.lang.ref.Reference;
 import java.lang.ref.ReferenceQueue;
 import java.lang.ref.WeakReference;
+import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ConcurrentMap;
@@ -363,10 +364,10 @@ public final void markReleased() {
              * This implements the proper way to free the allocated resources associated with the
              * reference.
              */
-            public abstract AsyncHandler.AsyncAction release();
+            public abstract AsyncAction release();
         }
 
-        static class SharedFinalizerErrorCallback implements AsyncHandler.AsyncAction {
+        static class SharedFinalizerErrorCallback implements AsyncAction {
 
             private final Exception exception;
             private final FinalizableReference referece; // problematic reference
@@ -382,6 +383,24 @@ public void execute(PythonContext context) {
             }
         }
 
+        private static final class AsyncActionsList implements AsyncAction {
+            private final AsyncAction[] array;
+
+            public AsyncActionsList(AsyncAction[] array) {
+                this.array = array;
+            }
+
+            public void execute(PythonContext context) {
+                for (AsyncAction action : array) {
+                    try {
+                        action.execute(context);
+                    } catch (RuntimeException e) {
+                        ExceptionUtils.printPythonLikeStackTrace(e);
+                    }
+                }
+            }
+        }
+
         /**
          * We register the Async action once on the first encounter of a creation of
          * {@link FinalizableReference}. This will reduce unnecessary Async thread load when there
@@ -395,17 +414,26 @@ public void registerAsyncAction() {
                 } catch (InterruptedException e) {
                     Thread.currentThread().interrupt();
                 }
-                if (reference instanceof FinalizableReference) {
-                    FinalizableReference object = (FinalizableReference) reference;
-                    try {
-                        liveReferencesSet.remove(object);
-                        if (object.isReleased()) {
-                            return null;
+                ArrayList<AsyncAction> actions = new ArrayList<>();
+                do {
+                    if (reference instanceof FinalizableReference) {
+                        FinalizableReference object = (FinalizableReference) reference;
+                        try {
+                            liveReferencesSet.remove(object);
+                            if (!object.isReleased()) {
+                                AsyncAction action = object.release();
+                                if (action != null) {
+                                    actions.add(action);
+                                }
+                            }
+                        } catch (Exception e) {
+                            actions.add(new SharedFinalizerErrorCallback(object, e));
                         }
-                        return object.release();
-                    } catch (Exception e) {
-                        return new SharedFinalizerErrorCallback(object, e);
                     }
+                    reference = queue.poll();
+                } while (reference != null);
+                if (!actions.isEmpty()) {
+                    return new AsyncActionsList(actions.toArray(new AsyncAction[0]));
                 }
                 return null;
             });

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/runtime/PythonOptions.java

@@ -244,6 +244,9 @@ private PythonOptions() {
     @Option(category = OptionCategory.EXPERT, help = "Set by the launcher to true (false means that GraalPython is being embedded in an application).") //
     public static final OptionKey<Boolean> RunViaLauncher = new OptionKey<>(false);
 
+    @Option(category = OptionCategory.EXPERT, help = "Enable built-in functions on the __graalpython__ module that are useful for debugging.") //
+    public static final OptionKey<Boolean> EnableDebuggingBuiltins = new OptionKey<>(false);
+
     public static final OptionDescriptors DESCRIPTORS = new PythonOptionsOptionDescriptors();
 
     @CompilationFinal(dimensions = 1) private static final OptionKey<?>[] ENGINE_OPTION_KEYS;

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/util/PythonUtils.java

@@ -297,6 +297,22 @@ public static void forceFullGC() {
         Runtime.getRuntime().freeMemory();
     }
 
+    @TruffleBoundary
+    public static void dumpHeap(String path) {
+        if (SERVER != null) {
+            try {
+                Class<?> mxBeanClass = Class.forName("com.sun.management.HotSpotDiagnosticMXBean");
+                Object mxBean = ManagementFactory.newPlatformMXBeanProxy(SERVER,
+                                "com.sun.management:type=HotSpotDiagnostic",
+                                mxBeanClass);
+                mxBeanClass.getMethod("dumpHeap", String.class, boolean.class).invoke(mxBean, path, true);
+            } catch (Throwable e) {
+                System.err.println("Cannot dump heap: " + e.getMessage());
+                e.printStackTrace();
+            }
+        }
+    }
+
     /**
      * Get the existing or create a new {@link CallTarget} for the provided root node.
      */

mx.graalpython/mx_graalpython.py

@@ -593,6 +593,7 @@ def run_python_unittests(python_binary, args=None, paths=None, aot_compatible=Fa
 
     args = args or []
     args = ["--experimental-options=true",
+            "--python.EnableDebuggingBuiltins",
             "--python.CatchAllExceptions=true"] + args
     exclude = exclude or []
     if env is None: