Removing need for asynchronous thread to execute ResourceManager finalizers

engine/interpreter-dsl-test/src/test/java/org/enso/interpreter/dsl/test/InliningBuiltinsOutNode.java

@@ -9,7 +9,7 @@
 final class InliningBuiltinsOutNode extends Node {
 
   long execute(VirtualFrame frame, long a, long b) {
-    Assert.assertNotNull("VirtualFrame is always provided " + frame);
+    Assert.assertNotNull("VirtualFrame is always provided", frame);
     return a + b;
   }
 

engine/runtime/src/main/java/org/enso/interpreter/runtime/ResourceManager.java

@@ -1,6 +1,7 @@
 package org.enso.interpreter.runtime;
 
 import com.oracle.truffle.api.CompilerDirectives;
+import com.oracle.truffle.api.ThreadLocalAction;
 import com.oracle.truffle.api.interop.InteropLibrary;
 import org.enso.interpreter.runtime.data.ManagedResource;
 
@@ -9,8 +10,12 @@
 import java.lang.ref.ReferenceQueue;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Future;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicReference;
 
 /** Allows the context to attach garbage collection hooks on the removal of certain objects. */
 public class ResourceManager {
@@ -124,7 +129,7 @@ public ManagedResource register(Object object, Object function) {
     }
     if (workerThread == null || !workerThread.isAlive()) {
       worker.setKilled(false);
-      workerThread = context.getEnvironment().createThread(worker);
+      workerThread = context.getEnvironment().createSystemThread(worker);
       workerThread.start();
     }
     ManagedResource resource = new ManagedResource(object);
@@ -234,14 +239,24 @@ public Item(Object underlying, Object finalizer, PhantomReference<ManagedResourc
      * @param context current execution context
      */
     public void doFinalize(EnsoContext context) {
-      Object p = context.getThreadManager().enter();
-      try {
-        InteropLibrary.getUncached(finalizer).execute(finalizer, underlying);
-      } catch (Exception e) {
-        context.getErr().println("Exception in finalizer: " + e.getMessage());
-      } finally {
-        context.getThreadManager().leave(p);
-      }
+      var futureToCancel = new AtomicReference<Future<Void>>(null);
+      var performFinalizer =
+          new ThreadLocalAction(false, false, true) {
+            @Override
+            protected void perform(ThreadLocalAction.Access access) {
+              var tmp = futureToCancel.getAndSet(null);
+              if (tmp == null) {
+                return;
+              }
+              tmp.cancel(false);
+              try {
+                InteropLibrary.getUncached(finalizer).execute(finalizer, underlying);
+              } catch (Exception e) {
+                context.getErr().println("Exception in finalizer: " + e.getMessage());
+              }
+            }
+          };
+      futureToCancel.set(context.getEnvironment().submitThreadLocal(null, performFinalizer));
     }
 
     /**

engine/runtime/src/test/scala/org/enso/interpreter/test/InterpreterTest.scala

@@ -113,6 +113,7 @@ class InterpreterContext(
       .newBuilder(LanguageInfo.ID)
       .allowExperimentalOptions(true)
       .allowAllAccess(true)
+      .allowCreateThread(false)
       .out(output)
       .err(err)
       .option(RuntimeOptions.LOG_LEVEL, "WARNING")

engine/runtime/src/test/scala/org/enso/interpreter/test/semantic/RuntimeManagementTest.scala

@@ -81,7 +81,11 @@ class RuntimeManagementTest extends InterpreterTest {
       totalOut = consumeOut
       while (totalOut.length < expect && round < 500) {
         round = round + 1
-        if (round % 10 == 0) forceGC();
+        if (round % 10 == 0) {
+          forceGC();
+        }
+        val res = eval("main a b = a * b").execute(7, 6)
+        assertResult(42)(res.asInt)
         Thread.sleep(100)
         totalOut ++= consumeOut
       }