bulk release shared finalizers rather than queueing many shared actions

Author: timfel

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;
             });