Turn thread termination resolution into a callback

This allows us later to store an initialised module. For now, it cleans up the scheduler
by decreasing the number of responsibilities.

Author: ssoelvsten

rt/src/Scheduler.mts

@@ -110,38 +110,46 @@ export class Scheduler implements SchedulerInterface {
         this.__funloop.push(t);
     }
 
-    /** Create a new thread `t` for the given function to be evaluated and schedule it. */
+    /** Create a new thread `t` for the given function to be evaluated and schedule it.
+     *
+     *  NOTE (20-10-2025; SS): A hypothesis about the Javascript event loop:
+     *
+     *       It would be a more clean design to return the thread identifier of type `LVal`, as we
+     *       do right now, together with a `Promise<LVal>` of the final returned value. But, since
+     *       the Javascript event loop is a LIFO queue, i.e. a stack, this would bury resolving the
+     *       termination of each thread (especially the *main* thread) beneath everything else.
+     */
     scheduleNewThread(f: () => any,
                       arg: any,
                       pc: Level,
                       block: Level,
-                      tType: ThreadType = ThreadType.Other)
+                      tType: ThreadType = ThreadType.Other,
+                      cb: (LVal) => void = (_) => {})
     {
         // Create a new process ID at the given level.
         const pid = tType === ThreadType.System ? SYSTEM_PROCESS_STRING : uuidv4();
-        const pidObj = new ProcessID(this.rt_uuid, pid, this.__node);
-        const newPid = new LVal(pidObj, pc);
+        const tid = new LVal(new ProcessID(this.rt_uuid, pid, this.__node), pc);
+
+        const halt = () => {
+            this.__currentThread.raiseCurrentThreadPCToBlockingLev();
+            this.notifyMonitors();
 
-        // Epilogue for thread.
-        const halt = tType === ThreadType.Main ? () => { this.haltMain() }
-                                               : () => { this.haltOther() };
+            const currT = this.__currentThread;
+            const retVal = new LVal (currT.r0_val, lub(currT.bl, currT.r0_lev), lub(currT.bl, currT.r0_tlev));
+
+            delete this.__alive[this.__currentThread.tid.val.toString()];
+
+            cb(retVal);
+        }
 
         // New thread
-        const t = new Thread
-            ( newPid
-            , halt
-            , f
-            , arg
-            , pc
-            , block
-            , new SandboxStatus.NORMAL()
-            , this.rtObj
-            , this );
-
-
-        this.__alive[newPid.val.toString()] = t;
+        const sStatus = new SandboxStatus.NORMAL();
+        const t = new Thread(tid, halt, f, arg, pc, block, sStatus, this.rtObj, this);
+
+        this.__alive[tid.val.toString()] = t;
         this.scheduleThread(t);
-        return newPid;
+
+        return tid as LVal;
     }
 
     /*************************************************************************************************\
@@ -210,32 +218,6 @@ export class Scheduler implements SchedulerInterface {
         }
     }
 
-    /** Epilogue for `main` thread: notify monitors, print and persist the final value  */
-    haltMain ()  {
-        this.__currentThread.raiseCurrentThreadPCToBlockingLev()
-        let retVal = new LVal (this.__currentThread.r0_val,
-                               lub(this.__currentThread.bl, this.__currentThread.r0_lev),
-                               lub(this.__currentThread.bl, this.__currentThread.r0_tlev))
-
-        this.notifyMonitors();
-
-      delete this.__alive[this.__currentThread.tid.val.toString()];
-        console.log(">>> Main thread finished with value:", retVal.stringRep());
-        const persist = argv[TroupeCliArg.Persist];
-        if (persist) {
-            this.rtObj.persist(retVal, persist)
-            console.log("Saved the result value in file", persist)
-        }
-        return null;
-    }
-
-    /** Epilogue for non-`main` threads: notify monitors  */
-    haltOther  ()  {
-        this.notifyMonitors();
-        // console.log (this.__currentThread.processDebuggingName, this.__currentThread.tid.val.toString(), "done")
-        delete this.__alive[this.__currentThread.tid.val.toString()];
-    }
-
     /** Kill thread `t` with the error message `s` sent to its monitors. */
     stopThreadWithErrorMessage (t: Thread, errMsg: string) {
         this.notifyMonitors(TerminationStatus.ERR, errMsg);

rt/src/builtins/spawn.mts

@@ -21,22 +21,13 @@ export function BuiltinSpawn<TBase extends Constructor<UserRuntimeZero>>(Base: T
             // console.log ("SPAWN ARGS", larg)
             this.runtime.$t.raiseCurrentThreadPC(larg.lev);
             let arg = larg.val;
-            let __sched = this.runtime.__sched
-            
 
-            let spawnLocal = (arg) => {
-                // debug ("scheduled rt_spawn ", arg.fun);
-
-                let newPid = __sched.scheduleNewThread(
-                    arg,
-                    __unit, // [arg.env, __unit],
-                    // arg.namespace,
-                    this.runtime.$t.pc,
-                    this.runtime.$t.bl)
-                return this.runtime.$t.returnImmediateLValue(newPid) ;
+            const spawnLocal = (func) => {
+                const tid = this.runtime.__sched.scheduleNewThread(
+                    func, __unit, this.runtime.$t.pc, this.runtime.$t.bl);
+                return this.runtime.$t.returnImmediateLValue(tid);
             }
 
-
             if (Array.isArray(arg)) {
                 if (__nodeManager.isLocalNode(arg[0].val)) { // check if we are at the same node or note
                     // debug ("SAME NODE")
@@ -55,4 +46,4 @@ export function BuiltinSpawn<TBase extends Constructor<UserRuntimeZero>>(Base: T
             }
         }, "spawn");
     }
-}
+}

rt/src/runtimeMonitored.mts

@@ -133,7 +133,7 @@ async function spawnFromRemote(jsonObj, fromNode) {
 
   const lf = await DS.deserialize(nodeLev, jsonObj);
   const f = lf.val;
-  const newPid =
+  const tid =
     __sched.scheduleNewThread(
       f
       , __unit //[f.env, __unit]
@@ -145,7 +145,7 @@ async function spawnFromRemote(jsonObj, fromNode) {
   // 2018-09-19: AA: because we need to send some info back, we have to invoke
   // serialization.
 
-  const serObj = serialize(newPid, levels.BOT).data
+  const serObj = serialize(tid, levels.BOT).data
   __sched.resumeLoopAsync();
   return serObj;
 }
@@ -278,6 +278,7 @@ function rt_ret (arg) {
   return $t().returnImmediateLValue(arg);
 }
 
+// TODO: Clean up the mess below...
 let __sched: Scheduler
 let __theMailbox: MailboxProcessor
 let __userRuntime: any
@@ -461,15 +462,24 @@ export async function start(f) {
 
   await __userRuntime.linkLibs(f);
 
+  const onTerminate = (retVal: LVal) => {
+    console.log(`>>> Main thread finished with value: ${retVal.stringRep()}`);
+    if (argv[TroupeCliArg.Persist]) {
+      this.rtObj.persist(retVal, argv[TroupeCliArg.Persist])
+      console.log("Saved the result value in file", argv[TroupeCliArg.Persist])
+    }
+  };
+
   __sched.scheduleNewThread(
     () => f.main({__dataLevel:levels.BOT})
     , mainAuthority
     , levels.BOT
     , levels.BOT
     , ThreadType.Main
+    , onTerminate
   );
 
   // ---------------------------------------------------------------------------
   // Start code execution
-  __sched.loop();
+  __sched.resumeLoopAsync();
 }