Merge with master.

Author: christianhaeubl

compiler/src/jdk.internal.vm.compiler/src/org/graalvm/compiler/graph/NodeMap.java

@@ -217,45 +217,57 @@ public T setValue(T newValue) {
         };
     }
 
-    @Override
-    public Iterable<T> getValues() {
-        return new Iterable<>() {
+    // Remove once GR-42126 is fixed
+    public class NodeMapIterable implements Iterable<T> {
 
-            @Override
-            public Iterator<T> iterator() {
-                return new Iterator<>() {
+        int i;
+        int pos;
 
-                    int i = 0;
+        @Override
+        public Iterator<T> iterator() {
+            return new Iterator<>() {
 
-                    @Override
-                    public boolean hasNext() {
-                        forward();
-                        return i < NodeMap.this.values.length;
-                    }
+                @Override
+                public boolean hasNext() {
+                    forward();
+                    return i < NodeMap.this.values.length;
+                }
 
-                    @SuppressWarnings("unchecked")
-                    @Override
-                    public T next() {
-                        final int pos = i;
-                        final T value = (T) NodeMap.this.values[pos];
+                @SuppressWarnings("unchecked")
+                @Override
+                public T next() {
+                    pos = i;
+                    final T value = (T) NodeMap.this.values[pos];
+                    i++;
+                    forward();
+                    return value;
+                }
+
+                @Override
+                public void remove() {
+                    throw new UnsupportedOperationException();
+                }
+
+                private void forward() {
+                    while (i < NodeMap.this.values.length && (NodeMap.this.values[i] == null || NodeMap.this.getKey(i) == null)) {
                         i++;
-                        forward();
-                        return value;
                     }
+                }
+            };
+        }
 
-                    @Override
-                    public void remove() {
-                        throw new UnsupportedOperationException();
-                    }
+        public int getI() {
+            return i;
+        }
 
-                    private void forward() {
-                        while (i < NodeMap.this.values.length && (NodeMap.this.values[i] == null || NodeMap.this.getKey(i) == null)) {
-                            i++;
-                        }
-                    }
-                };
-            }
-        };
+        public int getPos() {
+            return pos;
+        }
+    }
+
+    @Override
+    public Iterable<T> getValues() {
+        return new NodeMapIterable();
     }
 
     @Override

compiler/src/jdk.internal.vm.compiler/src/org/graalvm/compiler/java/LambdaUtils.java

@@ -55,6 +55,8 @@ public final class LambdaUtils {
     private static final char[] HEX = "0123456789abcdef".toCharArray();
     public static final String LAMBDA_SPLIT_PATTERN;
     public static final String LAMBDA_CLASS_NAME_SUBSTRING;
+    public static final String SERIALIZATION_TEST_LAMBDA_CLASS_SUBSTRING = "$$Lambda";
+    public static final String SERIALIZATION_TEST_LAMBDA_CLASS_SPLIT_PATTERN = "\\$\\$Lambda";
 
     static {
         if (Runtime.version().feature() < 21) {

compiler/src/jdk.internal.vm.compiler/src/org/graalvm/compiler/nodes/loop/LoopFragment.java

@@ -43,6 +43,7 @@
 import org.graalvm.compiler.graph.Node;
 import org.graalvm.compiler.graph.NodeBitMap;
 import org.graalvm.compiler.graph.NodeMap;
+import org.graalvm.compiler.graph.NodeMap.NodeMapIterable;
 import org.graalvm.compiler.graph.iterators.NodeIterable;
 import org.graalvm.compiler.nodes.AbstractBeginNode;
 import org.graalvm.compiler.nodes.AbstractMergeNode;
@@ -211,9 +212,12 @@ public Node replacement(Node o) {
                 Formatter f = new Formatter(sb);
                 StructuredGraph graph = graph();
                 if (duplicationMap instanceof NodeMap<?>) {
+                    NodeMap<?> nm = (NodeMap<?>) duplicationMap;
+                    @SuppressWarnings("rawtypes")
+                    NodeMap.NodeMapIterable nmIterable = (NodeMapIterable) duplicationNodes;
+                    f.format("GR-42126 iterable data: i=%s pos=%s nmSize=%s %n", nmIterable.getI(), nmIterable.getPos(), nm.capacity());
                     int nodeCount = graph.getNodeCount();
                     f.format("GR-42126 data: graph size %s,loop begin node count %s%n", nodeCount, graph.getNodes(LoopBeginNode.TYPE).count());
-                    NodeMap<?> nm = (NodeMap<?>) duplicationMap;
                     Object[] rawValues = nm.rawValues();
                     int nullEntries = 0;
                     for (int i = 0; i < rawValues.length; i++) {

docs/reference-manual/native-image/ReachabilityMetadata.md

@@ -349,7 +349,7 @@ Using this pattern has a positive side effect of improving security on the JVM a
 
 Wildcard patterns do the serialization registration only for lambda-proxy classes of an enclosing class. For example, to register lambda serialization in an enclosing class `pkg.LambdaHolder` use:
 ```java
-  ObjectInputFilter.Config.createFilter("pkg.LambdaHolder$$Lambda$*;")
+  ObjectInputFilter.Config.createFilter("pkg.LambdaHolder$$Lambda*;")
 ```
 
 Patterns like `"pkg.**"` and `"pkg.Prefix*"` will not perform serialization registration as they are too general and would increase image size significantly. 

docs/reference-manual/native-image/guides/build-and-run-native-executable-with-remote-jmx.md

@@ -13,6 +13,12 @@ Remote management using [Java Management Extensions (JMX)](https://www.oracle.co
 
 This guide covers the steps required to build, run, and interact with such a native executable using JMX.
 It also shows you how to register a custom managed bean (MBean), with the JMX server and the additional steps required for it to work with Native Image.
+## Currently Supported Features and Limitations
+Currently, JMX connection from a client to a remote MBean server is supported. The client, server, or both may be a native executable.
+For now, only MXBeans, and standard user-defined MBeans are supported. Dynamic and model MBeans are not currently supported because 
+their management interfaces are defined at runtime. Although remote management of MXBeans is supported, not all platform MXBean functionality 
+is implemented or is applicable in SubstrateVM. Additionally, in order to define and use standard MBeans, metadata configuration must be specified. 
+This is further explained later in this guide.    
 
 ## Step 1: Create a Demo Application
 

espresso/src/com.oracle.truffle.espresso/src/com/oracle/truffle/espresso/EspressoLanguage.java

@@ -295,6 +295,7 @@ protected void exitContext(EspressoContext context, ExitMode exitMode, int exitC
 
     @Override
     protected void finalizeContext(EspressoContext context) {
+        context.ensureThreadsJoined();
         TruffleSafepoint sp = TruffleSafepoint.getCurrent();
         boolean prev = sp.setAllowActions(false);
         try {

espresso/src/com.oracle.truffle.espresso/src/com/oracle/truffle/espresso/runtime/EspressoContext.java

@@ -932,6 +932,13 @@ public void destroyVM() {
         shutdownManager.destroyVM();
     }
 
+    public void ensureThreadsJoined() {
+        // shutdownManager could be null if we are closing a pre-initialized context
+        if (shutdownManager != null) {
+            shutdownManager.ensureThreadsJoined();
+        }
+    }
+
     public boolean isClosing() {
         return shutdownManager.isClosing();
     }

espresso/src/com.oracle.truffle.espresso/src/com/oracle/truffle/espresso/runtime/EspressoReferenceDrainer.java

@@ -115,12 +115,16 @@ void startReferenceDrain() {
         }
     }
 
-    void shutdownAndWaitReferenceDrain() throws InterruptedException {
+    void shutdownAndWaitReferenceDrain() {
         if (hostToGuestReferenceDrainThread != null) {
             while (hostToGuestReferenceDrainThread.isAlive()) {
                 getContext().getEnv().submitThreadLocal(new Thread[]{hostToGuestReferenceDrainThread}, new ExitTLA());
                 hostToGuestReferenceDrainThread.interrupt();
-                hostToGuestReferenceDrainThread.join(10);
+                try {
+                    hostToGuestReferenceDrainThread.join(10);
+                } catch (InterruptedException e) {
+                    // ignore
+                }
             }
         }
     }

espresso/src/com.oracle.truffle.espresso/src/com/oracle/truffle/espresso/runtime/EspressoShutdownHandler.java

@@ -27,6 +27,7 @@
 import java.util.function.Consumer;
 
 import com.oracle.truffle.api.CompilerDirectives.TruffleBoundary;
+import com.oracle.truffle.api.TruffleSafepoint;
 import com.oracle.truffle.api.exception.AbstractTruffleException;
 import com.oracle.truffle.espresso.blocking.EspressoLock;
 import com.oracle.truffle.espresso.blocking.GuestInterruptedException;
@@ -205,6 +206,34 @@ private boolean hasActiveNonDaemon(Thread initiating) {
         return false;
     }
 
+    public void ensureThreadsJoined() {
+        // wait indefinitely
+        ensureThreadsJoined(Thread.currentThread(), 0L);
+    }
+
+    private boolean ensureThreadsJoined(Thread initiatingThread, long maxWaitMillis) {
+        // Unconditionally kill
+        getContext().getLogger().finer("Teardown: Phase 3: Force kill with host EspressoExitExceptions");
+        teardownPhase3(initiatingThread);
+        boolean success = joinThreads(initiatingThread, true, maxWaitMillis);
+
+        // Special handling of the reference drainer
+        referenceDrainer.shutdownAndWaitReferenceDrain();
+
+        if (!success) {
+            getContext().getLogger().severe("Could not gracefully stop executing threads in context closing.");
+            getContext().getLogger().severe(() -> {
+                StringBuilder str = new StringBuilder("Threads still alive: ");
+                for (StaticObject guest : getManagedThreads()) {
+                    str.append(getThreadAccess().getHost(guest));
+                }
+                return str.toString();
+            });
+        }
+
+        return success;
+    }
+
     @SuppressWarnings("try")
     private void teardown() {
         assert isClosing();
@@ -216,7 +245,7 @@ private void teardown() {
             Thread initiatingThread = Thread.currentThread();
 
             getContext().getLogger().finer("Teardown: Phase 0: wait");
-            boolean nextPhase = !waitSpin(initiatingThread, false);
+            boolean nextPhase = !joinNonDaemonThreads(initiatingThread);
 
             if (softExit) {
                 // These phases give to running java thread a small window in which they can
@@ -225,39 +254,21 @@ private void teardown() {
                     // Send guest interruptions
                     getContext().getLogger().finer("Teardown: Phase 1: Interrupt threads.");
                     teardownPhase1(initiatingThread);
-                    nextPhase = !waitSpin(initiatingThread, false);
+                    nextPhase = !joinNonDaemonThreads(initiatingThread);
                 }
 
                 if (nextPhase) {
                     // Send guest ThreadDeaths
                     getContext().getLogger().finer("Teardown: Phase 2: Stop all threads.");
                     teardownPhase2(initiatingThread);
-                    nextPhase = !waitSpin(initiatingThread, false);
+                    nextPhase = !joinNonDaemonThreads(initiatingThread);
                 }
             }
 
-            // Unconditionally kill
-            getContext().getLogger().finer("Teardown: Phase 3: Force kill with host EspressoExitExceptions");
-            teardownPhase3(initiatingThread);
-            nextPhase = !waitSpin(initiatingThread, true);
-
-            // Special handling of the reference drainer
-            try {
-                referenceDrainer.shutdownAndWaitReferenceDrain();
-            } catch (InterruptedException e) {
-                // ignore
-            }
-
-            if (nextPhase) {
-                getContext().getLogger().severe("Could not gracefully stop executing threads in context closing.");
-                getContext().getLogger().severe(() -> {
-                    StringBuilder str = new StringBuilder("Threads still alive: ");
-                    for (StaticObject guest : getManagedThreads()) {
-                        str.append(getThreadAccess().getHost(guest));
-                    }
-                    return str.toString();
-                });
-                if (getContext().getEspressoEnv().AllowHostExit) {
+            boolean allowHostExit = getContext().getEspressoEnv().AllowHostExit;
+            // wait indefinitely if we can't kill the host
+            if (!ensureThreadsJoined(initiatingThread, allowHostExit ? MAX_KILL_PHASE_WAIT : 0L)) {
+                if (allowHostExit) {
                     // Needed until we can release rogue threads from Truffle (GR-28701).
                     getContext().getLogger().severe("Calling Host System.exit()...");
                     System.exit(getExitStatus());
@@ -306,31 +317,32 @@ private void teardownLoop(Consumer<StaticObject> action, Thread initiatingThread
         }
     }
 
+    private boolean joinNonDaemonThreads(Thread initiatingThread) {
+        return joinThreads(initiatingThread, false, MAX_KILL_PHASE_WAIT);
+    }
+
     /**
      * Waits for some time for all non-disposed threads to terminate.
      *
+     * @param maxWaitMillis the timeout for join operations, 0 for unlimited
+     *
      * @return true if all threads are completed, false otherwise.
      */
-    private boolean waitSpin(Thread initiatingThread, boolean waitForDaemon) {
-        long tick = System.currentTimeMillis();
-        spinLoop: //
-        while (true) {
-            long time = System.currentTimeMillis() - tick;
-            if (time > MAX_KILL_PHASE_WAIT) {
-                return false;
-            }
-            for (StaticObject guest : getManagedThreads()) {
-                Thread t = getThreadAccess().getHost(guest);
-                if (waitForDaemon || !t.isDaemon()) {
-                    if (t != initiatingThread && t != referenceDrainer.drainHostThread() /*- drain thread gets a custom shutdown */) {
+    private boolean joinThreads(Thread initiatingThread, boolean waitForDaemon, long maxWaitMillis) {
+        for (StaticObject guest : getManagedThreads()) {
+            Thread t = getThreadAccess().getHost(guest);
+            if (waitForDaemon || !t.isDaemon()) {
+                if (t != initiatingThread && t != referenceDrainer.drainHostThread() /*- drain thread gets a custom shutdown */) {
+                    if (t.isAlive()) {
+                        TruffleSafepoint.setBlockedThreadInterruptible(null, o -> t.join(maxWaitMillis), null);
                         if (t.isAlive()) {
-                            continue spinLoop;
+                            return false;
                         }
                     }
                 }
             }
-            return true;
         }
+        return true;
     }
 
     private Iterable<StaticObject> getManagedThreads() {

sdk/mx.sdk/mx_sdk_benchmark.py

@@ -420,7 +420,7 @@ def requestHeaders(self):
         return {}
 
     def inNativeMode(self):
-        return self.jvm(self.bmSuiteArgs) == "native-image"
+        return "native-image" in self.jvm(self.bmSuiteArgs)
 
     def createCommandLineArgs(self, benchmarks, bmSuiteArgs):
         return self.vmArgs(bmSuiteArgs) + ["-jar", self.applicationPath()]