handle multiple weakref callbacks that are available at once

Author: timfel

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

@@ -42,6 +42,7 @@
 
 import java.lang.ref.Reference;
 import java.lang.ref.ReferenceQueue;
+import java.util.ArrayList;
 import java.util.List;
 
 import com.oracle.graal.python.builtins.Builtin;
@@ -90,20 +91,28 @@ protected List<? extends NodeFactory<? extends PythonBuiltinBaseNode>> getNodeFa
     }
 
     private static class WeakrefCallbackAction extends AsyncHandler.AsyncPythonAction {
-        private final WeakRefStorage reference;
+        private final WeakRefStorage[] references;
+        private int index;
 
-        public WeakrefCallbackAction(PReferenceType.WeakRefStorage reference) {
-            this.reference = reference;
+        public WeakrefCallbackAction(WeakRefStorage[] weakRefStorages) {
+            this.references = weakRefStorages;
+            this.index = 0;
         }
 
         @Override
         public Object callable() {
-            return reference.getCallback();
+            return references[index].getCallback();
         }
 
         @Override
         public Object[] arguments() {
-            return new Object[]{reference.getRef()};
+            return new Object[]{references[index].getRef()};
+        }
+
+        @Override
+        public boolean proceed() {
+            index++;
+            return index < references.length;
         }
     }
 
@@ -124,11 +133,17 @@ public void postInitialize(PythonCore core) {
             } catch (InterruptedException e) {
                 Thread.currentThread().interrupt();
             }
-            if (reference instanceof PReferenceType.WeakRefStorage) {
-                return new WeakrefCallbackAction((PReferenceType.WeakRefStorage) reference);
-            } else {
-                return null;
+            ArrayList<PReferenceType.WeakRefStorage> refs = new ArrayList<>();
+            do {
+                if (reference instanceof PReferenceType.WeakRefStorage) {
+                    refs.add((PReferenceType.WeakRefStorage) reference);
+                }
+                reference = weakRefQueue.poll();
+            } while (reference != null);
+            if (!refs.isEmpty()) {
+                return new WeakrefCallbackAction(refs.toArray(new PReferenceType.WeakRefStorage[0]));
             }
+            return null;
         });
     }
 

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

@@ -109,27 +109,37 @@ protected int frameIndex() {
             return -1;
         }
 
+        /**
+         * As long as a subclass wants to run multiple callables in a single action, it can return
+         * {@code true} here.
+         */
+        protected boolean proceed() {
+            return false;
+        }
+
         @Override
         public final void execute(PythonContext context) {
             Object callable = callable();
-            if (callable != null) {
-                Object[] arguments = arguments();
-                Object[] args = PArguments.create(arguments.length + CallRootNode.ASYNC_ARG_COUNT);
-                PythonUtils.arraycopy(arguments, 0, args, PArguments.USER_ARGUMENTS_OFFSET + CallRootNode.ASYNC_ARG_COUNT, arguments.length);
-                PArguments.setArgument(args, CallRootNode.ASYNC_CALLABLE_INDEX, callable);
-                PArguments.setArgument(args, CallRootNode.ASYNC_FRAME_INDEX_INDEX, frameIndex());
+            do {
+                if (callable != null) {
+                    Object[] arguments = arguments();
+                    Object[] args = PArguments.create(arguments.length + CallRootNode.ASYNC_ARG_COUNT);
+                    PythonUtils.arraycopy(arguments, 0, args, PArguments.USER_ARGUMENTS_OFFSET + CallRootNode.ASYNC_ARG_COUNT, arguments.length);
+                    PArguments.setArgument(args, CallRootNode.ASYNC_CALLABLE_INDEX, callable);
+                    PArguments.setArgument(args, CallRootNode.ASYNC_FRAME_INDEX_INDEX, frameIndex());
 
-                try {
-                    GenericInvokeNode.getUncached().execute(context.getAsyncHandler().callTarget, args);
-                } catch (RuntimeException e) {
-                    // we cannot raise the exception here (well, we could, but CPython
-                    // doesn't), so we do what they do and just print it
-
-                    // Just print a Python-like stack trace; CPython does the same (see
-                    // 'weakrefobject.c: handle_callback')
-                    ExceptionUtils.printPythonLikeStackTrace(e);
+                    try {
+                        GenericInvokeNode.getUncached().execute(context.getAsyncHandler().callTarget, args);
+                    } catch (RuntimeException e) {
+                        // we cannot raise the exception here (well, we could, but CPython
+                        // doesn't), so we do what they do and just print it
+
+                        // Just print a Python-like stack trace; CPython does the same (see
+                        // 'weakrefobject.c: handle_callback')
+                        ExceptionUtils.printPythonLikeStackTrace(e);
+                    }
                 }
-            }
+            } while (proceed());
         }
     }