Automatic merge of master into galahad

Author: OracleLabsAutomation

espresso/src/com.oracle.truffle.espresso.jdwp/src/com/oracle/truffle/espresso/jdwp/api/JDWPContext.java

@@ -27,6 +27,8 @@
 import java.util.Set;
 
 import com.oracle.truffle.api.TruffleLanguage;
+import com.oracle.truffle.api.TruffleLanguage.Env;
+import com.oracle.truffle.api.TruffleThreadBuilder;
 import com.oracle.truffle.api.frame.Frame;
 import com.oracle.truffle.api.nodes.Node;
 import com.oracle.truffle.api.nodes.RootNode;
@@ -221,6 +223,21 @@ public interface JDWPContext {
      */
     Ids<Object> getIds();
 
+    /**
+     * Creates a new system thread.
+     *
+     * @return {@link Env#createSystemThread(java.lang.Runnable)}.
+     */
+    public Thread createSystemThread(Runnable runnable);
+
+    /**
+     * Creates a new polyglot thread bound to the Espresso language context.
+     *
+     * @return {@link Env#newTruffleThreadBuilder(java.lang.Runnable)}.{@link TruffleThreadBuilder#build()
+     *         build()}.
+     */
+    public Thread createPolyglotThread(Runnable runnable);
+
     /**
      * @param string guest language string object
      * @return true if object is a guest language String, false otherwise

espresso/src/com.oracle.truffle.espresso.jdwp/src/com/oracle/truffle/espresso/jdwp/impl/DebuggerConnection.java

@@ -24,9 +24,13 @@
 
 import java.io.IOException;
 import java.net.Socket;
+import java.util.concurrent.BlockingQueue;
 import java.util.concurrent.Callable;
 import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.LinkedBlockingQueue;
+import java.util.concurrent.atomic.AtomicBoolean;
 
+import com.oracle.truffle.api.TruffleSafepoint;
 import com.oracle.truffle.espresso.jdwp.api.ErrorCodes;
 import com.oracle.truffle.espresso.jdwp.api.JDWPContext;
 
@@ -43,7 +47,8 @@ private DebuggerConnection(SocketConnection connection, DebuggerController contr
     }
 
     static void establishDebuggerConnection(DebuggerController controller, DebuggerController.SetupState setupState, boolean isReconnect, CountDownLatch startupLatch) {
-        Thread jdwpReceiver = new Thread(new JDWPReceiver(controller, setupState, isReconnect, startupLatch), "jdwp-receiver");
+        Thread jdwpReceiver = controller.getContext().createSystemThread(new JDWPReceiver(controller, setupState, isReconnect, startupLatch));
+        jdwpReceiver.setName("jdwp-receiver");
         controller.addDebuggerReceiverThread(jdwpReceiver);
         jdwpReceiver.setDaemon(true);
         jdwpReceiver.start();
@@ -104,25 +109,22 @@ public void run() {
 
     private static class JDWPReceiver implements Runnable {
 
-        private static final Object NOT_ENTERED_MARKER = new Object();
         private DebuggerController.SetupState setupState;
         private final DebuggerController controller;
-        private RequestedJDWPEvents requestedJDWPEvents;
-        private DebuggerConnection debuggerConnection;
         private final boolean isReconnect;
         private final CountDownLatch latch;
 
         JDWPReceiver(DebuggerController controller, DebuggerController.SetupState setupState, boolean isReconnect, CountDownLatch latch) {
             this.setupState = setupState;
             this.controller = controller;
-            this.requestedJDWPEvents = new RequestedJDWPEvents(controller);
             this.isReconnect = isReconnect;
             this.latch = latch;
         }
 
         @Override
         public void run() {
             // first, complete the connection setup which is potentially blocking
+            DebuggerConnection debuggerConnection;
             try {
                 Socket connectionSocket;
                 if (setupState.socket != null) {
@@ -161,7 +163,8 @@ public void run() {
                     }
 
                     // OK, we're ready to fire up the JDWP transmitter thread too
-                    Thread jdwpSender = new Thread(new JDWPSender(socketConnection), "jdwp-transmitter");
+                    Thread jdwpSender = controller.getContext().createSystemThread(new JDWPSender(socketConnection));
+                    jdwpSender.setName("jdwp-transmitter");
                     controller.addDebuggerSenderThread(jdwpSender);
                     jdwpSender.setDaemon(true);
                     jdwpSender.start();
@@ -190,36 +193,75 @@ public void run() {
                 latch.countDown();
             }
             // Now, begin processing packets when they start to flow from the debugger.
-            // Make sure this thread is entered in the context
+            final BlockingQueue<Packet> packetQueue = new LinkedBlockingQueue<>();
+            final AtomicBoolean processorClose = new AtomicBoolean(false);
+            Thread jdwpProcessor = controller.getContext().createPolyglotThread(new JDWPProcessor(controller, debuggerConnection, packetQueue, processorClose));
+            jdwpProcessor.setName("jdwp-processor");
+            controller.addDebuggerProcessorThread(jdwpProcessor);
+            jdwpProcessor.setDaemon(true);
+            jdwpProcessor.start();
             try {
                 while (!Thread.currentThread().isInterrupted() && !controller.isClosing()) {
-                    Object previous = NOT_ENTERED_MARKER;
                     try {
-                        // get the packet outside the Truffle context, because it's a blocking IO
-                        // operation
                         Packet packet = Packet.fromByteArray(debuggerConnection.connection.readPacket());
-                        previous = controller.enterTruffleContext();
-                        processPacket(packet);
+                        packetQueue.add(packet);
                     } catch (IOException e) {
                         if (!debuggerConnection.isOpen()) {
                             // when the socket is closed, we're done
                             break;
                         }
                         if (!Thread.currentThread().isInterrupted()) {
                             controller.warning(() -> "Failed to process jdwp packet with message: " + e.getMessage());
+                            Thread.currentThread().interrupt(); // And set the interrupt flag again
                         }
                     } catch (ConnectionClosedException e) {
                         break;
-                    } finally {
-                        if (previous != NOT_ENTERED_MARKER) {
-                            controller.leaveTruffleContext(previous);
-                        }
                     }
                 }
             } finally {
+                processorClose.set(true);
+                jdwpProcessor.interrupt();
                 controller.getEventListener().onDetach();
             }
         }
+    }
+
+    private static class JDWPProcessor implements Runnable {
+
+        private final DebuggerController controller;
+        private final DebuggerConnection debuggerConnection;
+        private final RequestedJDWPEvents requestedJDWPEvents;
+        private final BlockingQueue<Packet> packetQueue;
+        private final AtomicBoolean close;
+
+        private JDWPProcessor(DebuggerController controller, DebuggerConnection debuggerConnection,
+                        BlockingQueue<Packet> packetQueue, AtomicBoolean close) {
+            this.controller = controller;
+            this.debuggerConnection = debuggerConnection;
+            this.requestedJDWPEvents = new RequestedJDWPEvents(controller);
+            this.packetQueue = packetQueue;
+            this.close = close;
+        }
+
+        @Override
+        public void run() {
+            while (!close.get()) {
+                Packet packet;
+                try {
+                    packet = TruffleSafepoint.getCurrent().setBlockedFunction(null, TruffleSafepoint.Interrupter.THREAD_INTERRUPT,
+                                    BlockingQueue::take, packetQueue, () -> breakIfClosed(), null);
+                } catch (ProcessorClosedException ex) {
+                    break;
+                }
+                processPacket(packet);
+            }
+        }
+
+        private void breakIfClosed() {
+            if (close.get()) {
+                throw new ProcessorClosedException();
+            }
+        }
 
         private void processPacket(Packet packet) {
             JDWPContext context = controller.getContext();
@@ -665,6 +707,11 @@ private void processPacket(Packet packet) {
                 debuggerConnection.handleReply(packet, new CommandResult(reply));
             }
         }
+
+        private static class ProcessorClosedException extends RuntimeException {
+
+            private static final long serialVersionUID = 8467327507834079474L;
+        }
     }
 
     private static CommandResult unknownCommandSet(Packet packet, DebuggerController controller) {

espresso/src/com.oracle.truffle.espresso.jdwp/src/com/oracle/truffle/espresso/jdwp/impl/DebuggerController.java

@@ -87,6 +87,7 @@ public final class DebuggerController implements ContextsListener {
     private JDWPContext context;
     private Thread senderThread;
     private Thread receiverThread;
+    private Thread processorThread;
     private volatile HandshakeController hsController = null;
     private final Lock resetting = new ReentrantLock();
     private volatile boolean isClosing;
@@ -169,7 +170,7 @@ public void reInitialize() {
         DebuggerConnection.establishDebuggerConnection(newController, newController.setupState, true, new CountDownLatch(1));
     }
 
-    public void reset(boolean prepareForReconnect) {
+    private void reset(boolean prepareForReconnect) {
         if (isClosing) {
             // already done closing, so don't attempt anything further
             return;
@@ -178,7 +179,6 @@ public void reset(boolean prepareForReconnect) {
             // mark that we're closing down the whole context
             isClosing = true;
         }
-        Thread currentReceiverThread = null;
         try {
             // begin section that needs to be synchronized with establishing a new connection and
             // starting the threads. The logic within the locked part, must be written in a way that
@@ -190,8 +190,6 @@ public void reset(boolean prepareForReconnect) {
             // when resuming all threads
             endSession();
 
-            currentReceiverThread = receiverThread;
-
             // Close the server socket used to listen for transport dt_socket.
             // This will unblock the accept call on a server socket.
             HandshakeController hsc = hsController;
@@ -225,9 +223,10 @@ public void reset(boolean prepareForReconnect) {
             resetting.unlock();
         }
 
-        // If we're not running in the receiver thread we should join
-        if (Thread.currentThread() != currentReceiverThread) {
-            joinThread(currentReceiverThread);
+        joinThread(receiverThread);
+        // If we're not running in the processor thread we should join
+        if (Thread.currentThread() != processorThread) {
+            joinThread(processorThread);
         }
 
         if (prepareForReconnect && !isClosing && isServer()) {
@@ -274,16 +273,23 @@ public void closeSocket() {
     }
 
     public void addDebuggerReceiverThread(Thread thread) {
+        assert receiverThread == null;
         receiverThread = thread;
     }
 
+    public void addDebuggerProcessorThread(Thread thread) {
+        assert processorThread == null;
+        processorThread = thread;
+    }
+
     public void addDebuggerSenderThread(Thread thread) {
+        assert senderThread == null;
         senderThread = thread;
     }
 
     public boolean isDebuggerThread(Thread hostThread) {
-        // only the receiver thread enters the context
-        return hostThread == receiverThread;
+        // only the procesor thread enters the context
+        return hostThread == processorThread;
     }
 
     public void markLateStartupError(Throwable t) {

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

@@ -125,6 +125,16 @@ public Ids<Object> getIds() {
         return ids;
     }
 
+    @Override
+    public Thread createSystemThread(Runnable runnable) {
+        return context.getEnv().createSystemThread(runnable);
+    }
+
+    @Override
+    public Thread createPolyglotThread(Runnable runnable) {
+        return context.getEnv().newTruffleThreadBuilder(runnable).build();
+    }
+
     @Override
     public boolean isString(Object string) {
         return Meta.isString(string);

regex/src/com.oracle.truffle.regex.test/src/com/oracle/truffle/regex/tregex/test/JsTests.java

@@ -688,6 +688,11 @@ public void generatedTests() {
         /* GENERATED CODE END - KEEP THIS MARKER FOR AUTOMATIC UPDATES */
     }
 
+    @Test
+    public void quantifierUnrollNFAExplosion() {
+        test("(?:\\3((?:[^]|.{0}|\\B|\ub9b5\\b|$){4,}){1,4})", "yim", "\ua3bb\n\n\u00a1\n\na\u2f77\n\n\ua3bb\n\n\u00a1\n\na\u2f77\n\n", 0, false);
+    }
+
     @Test
     public void overlappingBq() {
         testBoolean("(?=a{2,4})[ab]{4,68}c", "", NEVER_UNROLL_OPT, "aabbbbbbbbbbbbbbbbbbbbbbc", 0, true);