[GR-38039] [GR-64734] [GR-65060] Stricter thread status in Espresso.

PullRequest: graal/20833

Author: rakachan

espresso/src/com.oracle.truffle.espresso/src/com/oracle/truffle/espresso/blocking/BlockingSupport.java

@@ -65,8 +65,8 @@ private BlockingSupport(GuestInterrupter<T> guestInterrupter) {
     private final GuestInterrupter<T> guestInterrupter;
 
     /**
-     * Creates an instance of this interface, using the given {@link Interrupter guestInterrupter}
-     * parameter as how guest interruptions are made observable.
+     * Creates an instance of this interface, using the given {@link GuestInterrupter
+     * guestInterrupter} parameter as how guest interruptions are made observable.
      * <p>
      * This implementation can be as simple as setting a boolean in the guest's representation of
      * the thread.
@@ -93,7 +93,7 @@ public static <T> BlockingSupport<T> create(GuestInterrupter<T> guestInterrupter
      * 
      * As such, there are only three ways to retrieve control from a call to this method:
      * <ul>
-     * <li>The given {@linkplain Interruptible blockingRegion} naturally completes</li>
+     * <li>The given {@link Interruptible blockingRegion} naturally completes</li>
      * <li>{@link #guestInterrupt(Thread, Object)} is called for this thread.</li>
      * <li>An {@link ThreadLocalAction action} was submitted to this thread, that throws an
      * exception that is not an {@link InterruptedException}.</li>

espresso/src/com.oracle.truffle.espresso/src/com/oracle/truffle/espresso/blocking/EspressoLock.java

@@ -29,10 +29,14 @@
 import java.util.concurrent.locks.ReentrantLock;
 
 import com.oracle.truffle.api.CompilerDirectives.TruffleBoundary;
+import com.oracle.truffle.api.TruffleLogger;
 import com.oracle.truffle.api.TruffleSafepoint;
+import com.oracle.truffle.api.TruffleSafepoint.Interruptible;
 import com.oracle.truffle.api.nodes.Node;
+import com.oracle.truffle.espresso.EspressoLanguage;
 import com.oracle.truffle.espresso.impl.SuppressFBWarnings;
 import com.oracle.truffle.espresso.meta.Meta;
+import com.oracle.truffle.espresso.runtime.EspressoContext;
 import com.oracle.truffle.espresso.runtime.staticobject.StaticObject;
 
 /**
@@ -264,6 +268,7 @@ default boolean await(long timeout, TimeUnit unit) throws GuestInterruptedExcept
  */
 @SuppressWarnings("serial")
 final class EspressoLockImpl extends ReentrantLock implements EspressoLock {
+    private static final TruffleLogger LOGGER = TruffleLogger.getLogger(EspressoLanguage.ID, EspressoLock.class);
 
     private static final Node dummy = new Node() {
         @Override
@@ -322,7 +327,7 @@ public void lockInterruptible() throws GuestInterruptedException {
             // fast-path before involving safepoint support
             return;
         }
-        blockingSupport.enterBlockingRegion(EspressoLockImpl::doLock, dummy, this);
+        blockingSupport.enterBlockingRegion(Locker.LOCKER, dummy, this);
     }
 
     @Override
@@ -413,7 +418,7 @@ private void doLock() throws InterruptedException {
     }
 
     @SuppressFBWarnings(value = "UL_UNRELEASED_LOCK", justification = "this lock is released at the start of the method and re-acquired at the end")
-    private void enterWaitInterruptible(InterruptibleWithBooleanResult<EspressoLockImpl> interruptible) throws GuestInterruptedException {
+    private void enterWaitInterruptible(InterruptibleWithBooleanResult interruptible) throws GuestInterruptedException {
         ensureWaitLockInitialized();
         boolean enableManagement;
         Meta meta;
@@ -448,19 +453,26 @@ private void enterWaitInterruptible(InterruptibleWithBooleanResult<EspressoLockI
                              * Signaled exception is thrown.
                              */
                             this::afterSafepointForWait);
+            if (consumeSignal()) {
+                throw new Signaled(null);
+            }
+            interruptible.timedOut(); // Or spurious wake up.
         } catch (Signaled e) {
+            interruptible.signaled();
             e.maybeRethrow();
         } catch (Throwable e) {
             /*
              * Either GuestInterruptedException or an exception thrown by a safepoint. Since at that
              * point, we are still considered in waiting, we may have missed a signal.
              */
+            interruptible.interrupted();
             consumeSignal();
             throw e;
         } finally {
             if (enableManagement) {
                 meta.HIDDEN_THREAD_WAITING_MONITOR.setHiddenObject(interruptible.thread, StaticObject.NULL);
             }
+            waiters--;
             waitLock.unlock();
             // We need to ensure that we re-acquire the lock (even if the guest is getting
             // interrupted)
@@ -481,7 +493,11 @@ private void enterWaitInterruptible(InterruptibleWithBooleanResult<EspressoLockI
             for (int i = 1; i < holdCount; i++) {
                 lock();
             }
-            waiters--;
+            LOGGER.fine(() -> {
+                EspressoContext ctx = EspressoContext.get(null);
+                String tName = ctx.getMeta().toHostString(ctx.getMeta().java_lang_Thread_name.getObject(ctx.getCurrentPlatformThread()));
+                return "Wait for thread \"" + tName + "\" finished because it was " + interruptible.reason();
+            });
         }
     }
 
@@ -530,10 +546,27 @@ public Throwable fillInStackTrace() {
         }
     }
 
-    private abstract static class InterruptibleWithBooleanResult<T> implements TruffleSafepoint.Interruptible<T> {
+    private static final class Locker implements Interruptible<EspressoLockImpl> {
+        static final Interruptible<EspressoLockImpl> LOCKER = new Locker();
+
+        private Locker() {
+        }
+
+        @Override
+        public void apply(EspressoLockImpl lock) throws InterruptedException {
+            lock.doLock();
+        }
+    }
+
+    private abstract static class InterruptibleWithBooleanResult implements Interruptible<EspressoLockImpl> {
+        private static final byte SIGNALED = 0x1;
+        private static final byte INTERRUPTED = 0x2;
+        private static final byte TIMED_OUT = 0x4;
+
         private final StaticObject thread;
         private final StaticObject obj;
         private boolean result;
+        private byte status = 0;
 
         InterruptibleWithBooleanResult(StaticObject thread, StaticObject obj) {
             this.thread = thread;
@@ -547,9 +580,37 @@ public final boolean getResult() {
         public final void setResult(boolean result) {
             this.result = result;
         }
+
+        public void signaled() {
+            assert status == 0;
+            status = SIGNALED;
+        }
+
+        public void interrupted() {
+            assert status == 0;
+            status = INTERRUPTED;
+        }
+
+        public void timedOut() {
+            assert status == 0;
+            status = TIMED_OUT;
+        }
+
+        public String reason() {
+            switch (status) {
+                case SIGNALED:
+                    return "SIGNALED";
+                case INTERRUPTED:
+                    return "INTERRUPTED";
+                case TIMED_OUT:
+                    return "COMPLETED";
+                default:
+                    return "NONE";
+            }
+        }
     }
 
-    private static final class WaitInterruptible extends InterruptibleWithBooleanResult<EspressoLockImpl> {
+    private static final class WaitInterruptible extends InterruptibleWithBooleanResult {
         WaitInterruptible(long timeout, TimeUnit unit, StaticObject thread, StaticObject obj) {
             super(thread, obj);
             this.nanoTimeout = unit.toNanos(timeout);
@@ -575,9 +636,10 @@ public void apply(EspressoLockImpl lock) throws InterruptedException {
                 setResult(lock.waitCondition.await(left, TimeUnit.NANOSECONDS));
             }
         }
+
     }
 
-    private static final class WaitUntilInterruptible extends InterruptibleWithBooleanResult<EspressoLockImpl> {
+    private static final class WaitUntilInterruptible extends InterruptibleWithBooleanResult {
         WaitUntilInterruptible(Date date) {
             super(null, null);
             this.date = date;
@@ -593,5 +655,6 @@ public void apply(EspressoLockImpl lock) throws InterruptedException {
             // `enterWaitInterruptible`.
             setResult(lock.waitCondition.awaitUntil(date));
         }
+
     }
 }