@naanlang/naan 1.2.0 → 1.3.0

package/frameworks/running/executors.nlg

@@ -52,19 +52,28 @@ closure ExecutorBase(track, type, name, local exec) {
     }
     
     // execReceived
-    // THe specified message was received from the instance, so signal it.
+    // The specified message was received from the instance, so signal it.
     
     exec.execReceived = closure execReceived(data, local pending) {
         pending = exec.pending[data.xid]
-        if !pending {
+        if !pending {                                                       // not waiting on message
             if data.xmsg == "xready"
                 exec.pending.ready = true
+            if data.xmsg == "xattention"
+                { }
             return
         }
         exec.pending[data.xid] = undefined
         pending.signal(list(false, data))
     }
     
+    // execSetStatus
+    // Received a status update from the instance.
+    
+    exec.execSetStatus = function execSetStatus(status) {
+        exec.xstatus = status
+    }
+    
     // execFailed
     // Communication has failed.
     
@@ -263,21 +272,22 @@ closure ExecutorContext(exec, contextID, local context, util) {
  *
  * Allowable options are:
  *  {
- *      maxcount: <integer>                                                 // maximum workers, default 4
- *      initeval: `(<expr>, <put>, <get>)                                   // initializes each new worker
- *      basename: <string>                                                  // worker label for UI, default "batch"
+ *      spawnLoc: <string>                      // e.g. "Local" (default) or "Host"
+ *      maxcount: <integer>                     // maximum workers, default 4
+ *      initeval: `(<expr>, <put>, <get>)       // initializes each new worker
+ *      basename: <string>                      // worker label for UI, default "batch"
  *  }
  *
  */
 
-closure ExecutorParallel(options, local maxcount, basename, parallel, exqueue, crValue) {
+closure ExecutorParallel(track, options, local maxcount, parallel, exqueue, crValue) {
     global()
+    options = merge({
+        spawnLoc: "Local"
+        maxcount: 4
+        basename: "batch"
+    }, options)
     maxcount = options.maxcount
-    if !maxcount
-        maxcount = 4                                                        // default is 4 workers
-    basename = options.basename
-    if !string(basename)
-        basename = "batch"
     exqueue = []                                                            // waiting for execution
     parallel = new(object, this)
     parallel.workers = []                                                   // array of worker executors
@@ -288,36 +298,41 @@ closure ExecutorParallel(options, local maxcount, basename, parallel, exqueue, c
     //
     // Return the next available worker. If no workers are available and we haven't hit the maximum 
     // then create an additional worker and return it. If we cannot allocate another worker then this 
-    // returns false.
+    // returns { wait: true }.
     
     closure acquireWorker(local workdex, name, worker, context, result) {
         if parallel.available.length > 0
-            return (parallel.available.pop())
+            return (list(false, parallel.available.pop()))
         workdex = parallel.workers.length
         if workdex >= maxcount
-            return (false)
+            return (list(false, { wait: true }))
         parallel.workers[workdex] = false                                   // reserve our spot
-        name = basename.concat("-", workdex+1)
-        worker = App.nide.track.spawn("Local", name, "ExecutorParallel")    // ### App.nide.track.spawn may not exist
-        if worker.0 {                                                       // ### wasting space on workers list
+        name = options.basename.concat("-", workdex+1)
+        worker = track.spawn(options.spawnLoc, name, {
+            workerID: "ExecutorParallel"
+        })
+        if worker.0 {
+            parallel.workers.splice(workdex, 1)
             debuglog("execParallel: cannot spawn worker:", ErrorString(worker.0))
-            return (false)
+            return (list(worker.0))
         }
         worker = worker.1
         context = worker.context()
         if context.0 {
-            debuglog("execParallel: cannot create worker context:", ErrorString(context.0))
+            parallel.workers.splice(workdex, 1)
             worker.destroy()
-            return (false)
+            debuglog("execParallel: cannot create worker context:", ErrorString(context.0))
+            return (list(context.0))
         }
         context = context.1
         parallel.workers[workdex] = worker
         parallel.contexts[worker] = context
         if tuple(options.initeval) {
             result = apply(context.eval, options.initeval)
-            if result.0
-                debuglog("execParallel: cannot initialize worker", name, ErrorString(result.0)) }
-        return (worker)
+            if result.0 {
+                debuglog("execParallel: cannot initialize worker", name, ErrorString(result.0))
+                return (list(result.0)) } }
+        return (list(false, worker))
     }
     
     // releaseWorker
@@ -337,23 +352,26 @@ closure ExecutorParallel(options, local maxcount, basename, parallel, exqueue, c
     // don't remove work from the queue until we already have a worker.
     //
 
-    closure execNext(local worker, result) {
+    closure execNext(local error, worker, result) {
         if exqueue.length > 0 {
-            worker = acquireWorker()                                        // false if none available
-            if !worker {
-                if maxcount > 0 && parallel.workers.length == 0             // maxcount zero when being destroyed
-                    throw("execParallel: cannot allocate any workers at all")
-                return                                                      // we're busy, so try again later
+            `(error, worker) = acquireWorker()
+            if error {
+                if maxcount > 0 && parallel.workers.length == 0 {
+                    exqueue = []
+                    throw("execParallel: cannot allocate any workers at all") }
+                return                                                      // one failed, so try again later
             }
+            if worker.wait
+                return                                                      // we're busy, so try again later
             future(function(local next, context) {
                 next = exqueue.splice(0, 1).0                               // remove oldest entry, from start
                 if !next {
                     releaseWorker(worker)                                   // someone else already processed this
                     return
-               }
+                }
                 context = parallel.contexts[worker]
                 if next.eval
-                    result = apply(context.eval, next.args)
+                    result = apply(context.eval, next.eval)
                 else if next.proc
                     result = context.rpc(next.proc, next.args)
                 else
@@ -372,7 +390,7 @@ closure ExecutorParallel(options, local maxcount, basename, parallel, exqueue, c
     //
 
     parallel.eval = closure evalf(expr, put, get, local pending) {
-        if !maxcount
+        if maxcount == 0
             return (crValue)                                                // already destroyed
         pending = new(nonce)
         exqueue.push({
@@ -392,13 +410,55 @@ closure ExecutorParallel(options, local maxcount, basename, parallel, exqueue, c
         evalf(expr, eval(put), eval(get))
     }
     
+    // exBatch
+    //
+    // Remote helper to execute a batch function.
+    //
+    
+    closure exBatch(expr, local pending) {
+        // evaluate the expression in batch mode
+        function execbat() {
+            try {
+                pending.signal(list(false, evalactive(expr)))
+            } catch {
+                pending.signal(list(Error(exception)))
+            }
+        }
+
+        pending = new(nonce)
+        exec(list(execbat))
+        pending.wait()
+    }
+    
+    // batch
+    //
+    // Execute eval above in a remote in batch mode, waiting until it is complete.
+    //
+
+    parallel.batch = closure batchf(expr, put, get, local result) {
+        result = evalf(list(exBatch, list(quote, expr)), `(exBatch).append(put), get)
+        if result.0                                                         // unpack our error wrapper
+            result
+        else
+            result.1
+    }
+        
+    // batchq
+    //
+    // Evaluate the specified QUOTED expression in a remote in batch mode.
+    //
+    
+    parallel.batchq = macro batchq(expr, put, get) {
+        batchf(expr, eval(put), eval(get))
+    }
+
     // rpc
     //
     // Execute a procedure call in a remote worker.
     //
     
     parallel.rpc = closure rpc(proc, args, local pending) {
-        if !maxcount
+        if maxcount == 0
             return (crValue)                                                // already destroyed
         pending = new(nonce)
         exqueue.push({
@@ -410,13 +470,36 @@ closure ExecutorParallel(options, local maxcount, basename, parallel, exqueue, c
         pending.wait()
     }
 
+    // status
+    //
+    // Report status of workers. Each worker has a dictionary:
+    //  {
+    //      state:  <string>                    // "active" or "idle"
+    //      status: <dict>                      // like runaverage(1)
+    //  }
+    //
+
+    parallel.status = function status(local output, worker) {
+        output = []
+        for worker in parallel.workers {
+            output.push({
+                name: worker.name
+                type: worker.type
+                state: if parallel.available.indexOf(worker) >= 0
+                    "idle" else "active"
+                status: worker.xstatus
+            })
+        }
+        output
+    }
+
     // destroy
     //
     // Destroy the object by destroying the workers and failing pending requests with cancelResult.
     //
     
     parallel.destroy = closure destroy(cancelResult, local worker, next) {
-        if !maxcount
+        if maxcount == 0
             return (false)                                                  // already destroyed
         crValue = cancelResult
         maxcount = 0
@@ -542,6 +625,13 @@ closure ExecutorTracker(local xtrak) {
         } (pop(args), args)
     }
     
+    // parallel
+    // Return a new parallel executor with specified options.
+    
+    xtrak.parallel = function parallel(options) {
+        ExecutorParallel(xtrak, options)
+    }
+    
     xtrak.register(execLambda, "Lambda")
     
     // finis

package/frameworks/running/taskexec.nlg

@@ -28,12 +28,16 @@ closure TaskDispatcher(replier, local contexts, gohome, util) {
         reply = {
             xmsg: "error"
             xid: data.xid
+            _guid: data._guid || undefined
             error: "unknown operation"
         }
         try {
             restorens = makeActivator()
             if data.xmsg == "xstart"
-                reply = { xmsg: "xready" }                                  // ready to accept messages
+                reply = {                                                   // ready to accept messages
+                    xmsg: "xready"
+                     _guid: data._guid || undefined
+                }
             else if data.xmsg == "register" {
                 //
                 // register a new context to default namespace

package/lib/browser/env_web.js

@@ -6,7 +6,7 @@
  *
  * column positioning:                          //                          //                      !
  *
- * Copyright (c) 2017-2022 by Richard C. Zulch
+ * Copyright (c) 2017-2024 by Richard C. Zulch
  *
  */
 
@@ -223,7 +223,17 @@ exports.NaanControllerWeb = function() {
         }, 1);
     };
 
+    var replyHook;
+    this.OnReplyHook = function OnReplyHook(proc) {
+        replyHook = proc;
+        return (proc);
+    };
+
     this.ReplyMessage = function ReplyMessage(data) {                       // "remote" -> "local"
+        if (replyHook)
+            setTimeout(function() {
+                replyHook(data);
+            }, 1);
         termlist.forEach(function(term) {
             if (term.OnMessageOut)
                 term.OnMessageOut(data);
@@ -526,7 +536,7 @@ exports.NaanControllerWeb = function() {
         statedoc.curversion = kStateCurrentVersion;
         statedoc.firstver = kStateFirstVersion;
         statedoc.licensee = "MIT-License";
-        statedoc.verstring = "1.2.0+1";
+        statedoc.verstring = "1.3.0+1";
         statedoc.date = new Date().toISOString();
         statedoc.prefs = prefs;
         statedoc.naan = naanlib.saveState(false);                           // true to optimize, which is a bit slower
@@ -544,7 +554,7 @@ exports.NaanControllerWeb = function() {
             || statedoc.firstver > kStateCurrentVersion
             || statedoc.curversion < kStateFirstVersion
             || statedoc.licensee != "MIT-License"
-            || statedoc.verstring != "1.2.0+1")
+            || statedoc.verstring != "1.3.0+1")
         {
             localStorage.removeItem("NaanState_Hosted");
             return (false);
@@ -603,7 +613,7 @@ exports.NaanControllerWeb = function() {
                     op: "VsiteOpen",
                     name: vsiteName,
                     naancont: contSelf,
-                    title: vsiteName + " 1.2.0+1"
+                    title: vsiteName + " 1.3.0+1"
                 });
             }
         } catch (e) {
@@ -617,7 +627,7 @@ exports.NaanControllerWeb = function() {
                     op: "VsiteClose",
                     name: vsiteName,
                     naancont: contSelf,
-                    title: vsiteName + " 1.2.0+1"
+                    title: vsiteName + " 1.3.0+1"
                 });
                 termTextOut("\x1b[90m\x1b[3m".concat("\nwindow closed", "\x1b[0m\n"));
             }
@@ -632,8 +642,8 @@ exports.NaanControllerWeb = function() {
         naanlib.banner();
         var hostpath = naanlib.js.r("path").dirname(window.location.href);
         naanlib.start({
-            cmd: 'App.version = "1.2.0+1";;\r\n'
-                + 'App.cache = "9659b00cb48debdc9726030789336e68";;\r\n'
+            cmd: 'App.version = "1.3.0+1";;\r\n'
+                + 'App.cache = "49a9b89fb804111a36026df163e15009";;\r\n'
                 + 'Naan.module.requireQuery({ naanver: App.cache });;\r\n'
                 + 'Naan.module.webparse("naan_init.nlg", "' + hostpath + '", { naanver: App.cache });;\r\n'
         });

package/lib/browser/env_webworker.js

@@ -6,7 +6,7 @@
  *
  * column positioning:                          //                          //                      !
  *
- * Copyright (c) 2019-2022 by Richard C. Zulch
+ * Copyright (c) 2019-2024 by Richard C. Zulch
  *
  */
 
@@ -83,13 +83,27 @@ exports.NaanControllerWebWorker = function NaanControllerWebWorker() {
         });
         return (data);
     };
-    
+
     var targetListener;
     targSelf.OnMessage = function OnMessage(proc) {
         targetListener = proc;
         return (proc);
     };
-    
+
+    this.DispatchMessage = function DispatchMessage(data) {
+        postMessage({                                                       // target is sending a message
+            id: "targetsend",
+            data: data
+        });
+        return (data);
+    };
+
+    var targetReceiver;
+    targSelf.OnReceive = function OnReceive(proc) {
+        targetReceiver = proc;
+        return (proc);
+    };
+
     targSelf.ReplyDebugger = function ReplyDebugger(data) {
         postMessage({                                                       // target is sending debug data
             id: "debugout",
@@ -149,6 +163,11 @@ exports.NaanControllerWebWorker = function NaanControllerWebWorker() {
             if (debugListener)
                 debugListener(msg.data);                                    // target received a message
         }
+        else if (msg.id == "targetreceive")
+        {
+            if (targetReceiver)
+                targetReceiver(msg.data);
+        }
     };
     
     //