[GR-64886] Reinforce assertions during thread registration.

PullRequest: graal/20769

Author: rakachan

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

@@ -163,7 +163,7 @@ public final class EspressoLanguage extends TruffleLanguage<EspressoContext> imp
 
     @CompilationFinal private GuestFieldOffsetStrategy guestFieldOffsetStrategy;
 
-    private final ContextThreadLocal<EspressoThreadLocalState> threadLocalState = locals.createContextThreadLocal((context, thread) -> new EspressoThreadLocalState(context));
+    private final ContextThreadLocal<EspressoThreadLocalState> threadLocalState = locals.createContextThreadLocal(EspressoThreadLocalState::new);
 
     public EspressoLanguage() {
         // Initialize statically defined symbols and substitutions.

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

@@ -22,6 +22,8 @@
  */
 package com.oracle.truffle.espresso.runtime;
 
+import java.lang.ref.WeakReference;
+
 import com.oracle.truffle.api.CompilerDirectives;
 import com.oracle.truffle.espresso.impl.ClassRegistry;
 import com.oracle.truffle.espresso.runtime.staticobject.StaticObject;
@@ -47,10 +49,13 @@ public class EspressoThreadLocalState {
 
     private boolean inTransformer;
 
+    private WeakReference<Thread> hostThread;
+
     @SuppressWarnings("unused")
-    public EspressoThreadLocalState(EspressoContext context) {
+    public EspressoThreadLocalState(EspressoContext context, Thread t) {
         typeStack = new ClassRegistry.TypeStack();
         privilegedStack = new VM.PrivilegedStack(context);
+        assert ((hostThread = new WeakReference<>(t)) != null);
     }
 
     public StaticObject getPendingExceptionObject() {
@@ -76,8 +81,7 @@ public void clearPendingException() {
 
     public void setCurrentPlatformThread(StaticObject t) {
         assert t != null && StaticObject.notNull(t);
-        assert t.getKlass().getContext().getThreadAccess().getHost(t) == Thread.currentThread() : "Current thread fast access set by non-current thread";
-        assert currentPlatformThread == null || currentPlatformThread == t : currentPlatformThread + " vs " + t;
+        assert diagnose(t);
         currentPlatformThread = t;
     }
 
@@ -87,6 +91,7 @@ public void setCurrentVirtualThread(StaticObject t) {
     }
 
     public void initializeCurrentThread(StaticObject t) {
+        assert diagnose(t);
         setCurrentPlatformThread(t);
         setCurrentVirtualThread(t);
     }
@@ -213,4 +218,56 @@ public void close() {
             inTransformer = false;
         }
     }
+
+    // Helper methods for assertions
+    private boolean diagnose(StaticObject t) {
+        // @formatter:off
+        // Ensure we work from the thread used for this local creation.
+        assert Thread.currentThread() == hostThread.get() : //
+                "Initializing current thread in EspressoThreadLocalState for a different thread than current:\n" +
+                "    Current: " + Thread.currentThread() + "\n" +
+                "    Registered: " + hostThread.get();
+
+        // Ensure the registered guest thread is and stays linked to the corresponding host thread.
+        if (currentPlatformThread != null) {
+            assert getHost(currentPlatformThread) == Thread.currentThread() : //
+                    "Registered platform thread not associated with current host thread.";
+        }
+
+        // Ensure we are consistently registering guest threads.
+        if (t != null) {
+            // The thread we are registering is linked to the current thread.
+            assert getHost(t) == Thread.currentThread() : //
+                    "Current thread fast access set by non-current thread";
+
+            // Ensure we are not registering multiple guest threads for the same host thread.
+            assert currentPlatformThread == null || currentPlatformThread == t : //
+                    /*- Report these threads names */
+                    getHost(currentPlatformThread).getName() + " vs " + getHost(t).getName() + "\n" +
+                    /*- Report these threads identities */
+                    "Guest identities" + System.identityHashCode(currentPlatformThread) + " vs " + System.identityHashCode(t) + "\n" +
+                    /*- Checks if our host threads are actually different, or if it is simply a renamed one. */
+                    "Host identities: " + System.identityHashCode(getHost(currentPlatformThread)) + " vs " + System.identityHashCode(getHost(t));
+        }
+        // @formatter:on
+        /*-
+         * Current theory for GR-50089:
+         *
+         * For some reason, when creating a new guest thread, instead of spawning a new host thread
+         * Truffle gives us back a previously created one that had completed.
+         *
+         * If that is the case, then, on failure, we will see in the report:
+         * - Different guest names and/or guest identities
+         * - Same host identities
+         *
+         * This may be solved by unregistering a guest thread from the thread local state in
+         * ThreadAccess.terminate().
+         */
+        return true;
+    }
+
+    private static Thread getHost(StaticObject t) {
+        assert t != null && StaticObject.notNull(t);
+        return t.getKlass().getContext().getThreadAccess().getHost(t);
+    }
 }