@woosh/meep-engine 2.49.6 → 2.49.7

package/src/core/process/executor/ConcurrentExecutor.js

@@ -7,7 +7,6 @@ import { IllegalStateException } from "../../fsm/exceptions/IllegalStateExceptio
 import { objectKeyByValue } from "../../model/object/objectKeyByValue.js";
 import { TaskSignal } from "../task/TaskSignal.js";
 import TaskState from "../task/TaskState.js";
-import { clamp } from "../../math/clamp.js";
 
 /**
  *
@@ -22,13 +21,20 @@ function isGroup(t) {
  * @class
  */
 class ConcurrentExecutor {
+    #cycle_count = 0;
+    /**
+     * Handle of the last scheduled `setTimeout`
+     * @type {number}
+     */
+    #timeout_handle = -1;
+
     /**
      *
      * @param {number} [quietTime] in milliseconds
      * @param {number} [workTime] in milliseconds
      * @constructor
      */
-    constructor(quietTime=1, workTime=15) {
+    constructor(quietTime = 1, workTime = 15) {
         /**
          *
          * @type {number}
@@ -58,6 +64,8 @@ class ConcurrentExecutor {
             completed: new Signal()
         };
 
+        this.busy = false;
+
         /**
          *
          * @type {number|SchedulingPolicy}
@@ -298,142 +306,188 @@ class ConcurrentExecutor {
     }
 
     /**
-     * kicks the scheduler into action, this is an internal method and should not be called from outside
-     * @private
+     *
+     * @return {Task|undefined}
      */
-    prod() {
-        const self = this;
+    #pick_next_task() {
+        const ready = this.queueReady;
+
+        switch (this.policy) {
+            case ConcurrentExecutor.POLICY.ROUND_ROBIN:
+                return ready[this.#cycle_count % ready.length];
+            default:
+                console.warn('Unknown scheduling policy: ', this.policy, 'Defaulting to sequential');
+            // fallthrough
+            case ConcurrentExecutor.POLICY.SEQUENTIAL:
+                return ready[0];
+        }
+    }
+
+    /**
+     *
+     * @param {Task} task
+     */
+    #complete_task(task) {
+        const readyTasks = this.queueReady;
+
+        const taskIndex = readyTasks.indexOf(task);
+
+        if (taskIndex !== -1) {
+            readyTasks.splice(taskIndex, 1);
+        } else {
+            console.error("Failed to remove ready task, not found in the ready queue", task, readyTasks.slice());
+        }
+
 
-        let i = 0;
+        task.state.set(TaskState.SUCCEEDED);
+        task.on.completed.send1(this);
 
         this.resolveTasks();
 
+        this.on.task_completed.send1(task);
+        // console.warn(`Task complete '${task.name}', cycles=${task.__executedCycleCount}, time=${task.__executedCpuTime}`);
+
+    }
+
+    /**
+     *
+     * @param {Task} task
+     * @param {*} [reason]
+     */
+    #fail_task(task, reason) {
         const readyTasks = this.queueReady;
-        let readyTaskCount;
+        const taskIndex = readyTasks.indexOf(task);
 
-        function updateTaskCount() {
-            readyTaskCount = readyTasks.length;
+        if (taskIndex !== -1) {
+            readyTasks.splice(taskIndex, 1);
+        } else {
+            console.error("Failed to remove ready task, not found in the ready queue", task, readyTasks.slice());
         }
 
-        function pickNextTaskRoundRobin() {
-            return readyTasks[i++ % readyTaskCount];
-        }
+        task.state.set(TaskState.FAILED);
+        task.on.failed.send1(reason);
 
-        function pickNextTaskSequential() {
-            return readyTasks[0];
-        }
+        this.resolveTasks();
 
-        /**
-         * @type {function():Task}
-         */
-        let pickNextTask;
+        this.on.task_completed.send1(task);
+    }
 
-        switch (this.policy) {
-            case ConcurrentExecutor.POLICY.ROUND_ROBIN:
-                pickNextTask = pickNextTaskRoundRobin;
-                break;
-            case ConcurrentExecutor.POLICY.SEQUENTIAL:
-                pickNextTask = pickNextTaskSequential;
-                break;
-            default:
-                console.warn('Unknown scheduling policy: ', this.policy, 'Defaulting to sequential');
-                pickNextTask = pickNextTaskSequential;
-                break;
-        }
+    /**
+     *
+     * @param {Task} task
+     * @param {number} time in milliseconds
+     * @param {function} completionCallback
+     * @param {function} failureCallback
+     */
+    #runTaskForTimeMonitored(task, time) {
+        let cycle_count = 0;
 
         /**
          *
-         * @param {Task} task
+         * @type {function(): TaskSignal}
          */
-        function completeTask(task) {
+        const cycle = task.cycle;
 
-            const taskIndex = readyTasks.indexOf(task);
+        const startTime = performance.now();
 
-            if (taskIndex !== -1) {
-                readyTasks.splice(taskIndex, 1);
-            } else {
-                console.error("Failed to remove ready task, not found in the ready queue", task, readyTasks.slice());
-            }
+        const endTime = startTime + time;
 
+        //We use tiny delta to avoid problems with timer accuracy on some systems that result in 0 measured execution time
+        let t = startTime + 0.000001;
 
-            task.state.set(TaskState.SUCCEEDED);
-            task.on.completed.send1(self);
+        let signal;
 
-            self.resolveTasks();
-            updateTaskCount();
+        while (t < endTime) {
+            cycle_count++;
 
-            self.on.task_completed.send1(task);
-            // console.warn(`Task complete '${task.name}', cycles=${task.__executedCycleCount}, time=${task.__executedCpuTime}`);
-        }
+            signal = cycle();
+            t = performance.now();
 
-        /**
-         *
-         * @param {Task} task
-         * @param {*} reason
-         */
-        function failTask(task, reason) {
-            const taskIndex = readyTasks.indexOf(task);
+            if (signal === TaskSignal.Continue) {
+                continue;
+            }
+
+            if (signal === TaskSignal.Yield) {
+                //give up current quanta
+                break;
+            }
 
-            if (taskIndex !== -1) {
-                readyTasks.splice(taskIndex, 1);
+            if (signal === TaskSignal.EndSuccess) {
+                break;
+            } else if (signal === TaskSignal.EndFailure) {
+                break;
             } else {
-                console.error("Failed to remove ready task, not found in the ready queue", task, readyTasks.slice());
+                throw new Error(`Task '${task.name}' produced unknown signal: ` + signal);
             }
+        }
 
-            task.state.set(TaskState.FAILED);
-            task.on.failed.dispatch(reason);
+        const executionDuration = t - startTime;
 
-            self.resolveTasks();
-            updateTaskCount();
+        task.__executedCpuTime += executionDuration;
+        task.__executedCycleCount += cycle_count;
 
-            self.on.task_completed.send1(task);
+        if (signal === TaskSignal.EndSuccess) {
+            this.#complete_task(task);
+        } else if (signal === TaskSignal.EndFailure) {
+            this.#fail_task(task, "Task signalled failure");
         }
 
-        function executeTimeSlice() {
-            let sliceTimeLeft = self.workTime;
+        return executionDuration;
+    }
 
-            let executionTime = 0;
+    #bound_executeTimeSlice = this.#executeTimeSlice.bind(this);
 
-            while (readyTaskCount > 0) {
-                const task = pickNextTask();
+    #executeTimeSlice() {
+        let sliceTimeLeft = this.workTime;
 
-                if (task === undefined) {
-                    console.warn('Next task not found, likely result of removing task mid-execution');
-                    break;
-                }
+        let executionTime = 0;
 
-                try {
-                    executionTime = runTaskForTimeMonitored(task, sliceTimeLeft, completeTask, failTask);
-                } catch (e) {
-                    console.error(`Task threw an exception`, task, e);
-                    failTask(task, e);
-                }
+        const queueReady = this.queueReady;
 
-                //make sure that execution time that we subtract from current CPU slice is always reducing the slice
-                sliceTimeLeft -= Math.max(executionTime, 1);
+        while (queueReady.length > 0) {
+            const task = this.#pick_next_task();
 
-                if (sliceTimeLeft <= 0) {
-                    break;
-                }
+            if (task === undefined) {
+                console.warn('Next task not found, likely result of removing task mid-execution');
+                break;
             }
 
-            //update task count
-            updateTaskCount();
+            try {
+                executionTime = this.#runTaskForTimeMonitored(task, sliceTimeLeft);
+            } catch (e) {
+                console.error(`Task threw an exception`, task, e);
+                this.#fail_task(task, e);
+            }
 
-            if (readyTaskCount > 0) {
-                //schedule next time slice
-                setTimeout(executeTimeSlice, self.quietTime);
-            } else {
-                self.busy = false;
-                self.on.completed.send0();
+            this.#cycle_count++;
+
+            //make sure that execution time that we subtract from current CPU slice is always reducing the slice
+            sliceTimeLeft -= Math.max(executionTime, 1);
+
+            if (sliceTimeLeft <= 0) {
+                break;
             }
         }
 
-        updateTaskCount();
+        if (this.queueReady.length === 0) {
+            this.busy = false;
+            this.on.completed.send0();
+        } else {
+            //schedule next time slice
+            this.#timeout_handle = setTimeout(this.#bound_executeTimeSlice, this.quietTime);
+        }
+    }
+
+    /**
+     * kicks the scheduler into action, this is an internal method and should not be called from outside
+     * @private
+     */
+    prod() {
+        this.resolveTasks();
 
-        if (!this.busy && readyTaskCount > 0) {
+        if (!this.busy && this.queueReady.length > 0) {
             this.busy = true;
-            executeTimeSlice();
+            this.#executeTimeSlice();
         }
 
     }
@@ -459,147 +513,6 @@ const SchedulingPolicy = {
 
 ConcurrentExecutor.POLICY = SchedulingPolicy;
 
-/**
- *
- * @param {Task} task
- * @param {number} time in milliseconds
- * @param {function} completionCallback
- * @param {function} failureCallback
- */
-function runTaskForTimeEstimated(task, time, completionCallback, failureCallback) {
-    let cycle_count = 0;
-
-    /**
-     *
-     * @type {function(): TaskSignal}
-     */
-    const cycle = task.cycle;
-
-    const startTime = performance.now();
-
-    let signal;
-
-    const cycle_time = task.__executedCpuTime / task.__executedCycleCount;
-
-    const estimated_cycles = clamp(Math.ceil(time / cycle_time), 1, 10000);
-
-    while (cycle_count < estimated_cycles) {
-        cycle_count++
-
-        signal = cycle();
-
-        if (signal === TaskSignal.Continue) {
-            continue;
-        }
-
-        if (signal === TaskSignal.Yield) {
-            //give up current quanta
-            break;
-        }
-
-        if (signal === TaskSignal.EndSuccess) {
-            break;
-        } else if (signal === TaskSignal.EndFailure) {
-            break;
-        } else {
-            throw new Error(`Task '${task.name}' produced unknown signal: ` + signal);
-        }
-    }
-
-    //We use tiny delta to avoid problems with timer accuracy on some systems that result in 0 measured execution time
-    const endTime = performance.now() + 0.000001;
-
-    const executionDuration = endTime - startTime;
-
-    task.__executedCpuTime += executionDuration;
-    task.__executedCycleCount += cycle_count;
-
-    if (signal === TaskSignal.EndSuccess) {
-        completionCallback(task);
-    } else if (signal === TaskSignal.EndFailure) {
-        failureCallback(task, "Task signalled failure");
-    }
-
-    return executionDuration;
-}
-
-/**
- *
- * @param {Task} task
- * @param {number} time in milliseconds
- * @param {function} completionCallback
- * @param {function} failureCallback
- */
-function runTaskForTime2(task, time, completionCallback, failureCallback) {
-    if (task.__executedCycleCount > 1000) {
-        return runTaskForTimeEstimated(task, time, completionCallback, failureCallback);
-    } else {
-        return runTaskForTimeMonitored(task, time, completionCallback, failureCallback);
-    }
-}
-
-/**
- *
- * @param {Task} task
- * @param {number} time in milliseconds
- * @param {function} completionCallback
- * @param {function} failureCallback
- */
-function runTaskForTimeMonitored(task, time, completionCallback, failureCallback) {
-    let cycle_count = 0;
-
-    /**
-     *
-     * @type {function(): TaskSignal}
-     */
-    const cycle = task.cycle;
-
-    const startTime = performance.now();
-
-    const endTime = startTime + time;
-
-    //We use tiny delta to avoid problems with timer accuracy on some systems that result in 0 measured execution time
-    let t = startTime + 0.000001;
-
-    let signal;
-
-    while (t < endTime) {
-        cycle_count++;
-
-        signal = cycle();
-        t = performance.now();
-
-        if (signal === TaskSignal.Continue) {
-            continue;
-        }
-
-        if (signal === TaskSignal.Yield) {
-            //give up current quanta
-            break;
-        }
-
-        if (signal === TaskSignal.EndSuccess) {
-            break;
-        } else if (signal === TaskSignal.EndFailure) {
-            break;
-        } else {
-            throw new Error(`Task '${task.name}' produced unknown signal: ` + signal);
-        }
-    }
-
-    const executionDuration = t - startTime;
-
-    task.__executedCpuTime += executionDuration;
-    task.__executedCycleCount += cycle_count;
-
-    if (signal === TaskSignal.EndSuccess) {
-        completionCallback(task);
-    } else if (signal === TaskSignal.EndFailure) {
-        failureCallback(task, "Task signalled failure");
-    }
-
-    return executionDuration;
-}
 
 const ResolutionType = {
     READY: 0,

package/src/engine/intelligence/blackboard/Blackboard.d.ts

@@ -1,5 +1,9 @@
 import {AbstractBlackboard} from "./AbstractBlackboard";
 
 export class Blackboard extends AbstractBlackboard {
+    toJSON(): { [key: string]: (number | boolean | string) }
 
+    fromJSON(json: any): void
+
+    static fromJSON(json: any): Blackboard
 }

package/src/engine/intelligence/blackboard/Blackboard.js

@@ -215,6 +215,17 @@ export class Blackboard extends AbstractBlackboard {
 
         }
     }
+
+    /**
+     *
+     * @param {any} json
+     * @return {Blackboard}
+     */
+    static fromJSON(json) {
+        const bb = new Blackboard();
+        bb.fromJSON(json);
+        return bb;
+    }
 }
 
 Blackboard.typeName = 'Blackboard';

package/src/view/tooltip/gml/parser/readReferenceValueToken.js

@@ -1,8 +1,8 @@
 import ParserError from "../../../../core/parser/simple/ParserError.js";
-import { readLiteral } from "../../../../core/parser/simple/SimpleParser.js";
 import { KeyValuePair } from "../../../../core/collection/KeyValuePair.js";
 import Token from "../../../../core/parser/simple/Token.js";
 import { TooltipTokenType } from "./TooltipTokenType.js";
+import { readLiteralToken } from "../../../../core/parser/simple/readLiteralToken.js";
 
 /**
  *
@@ -41,7 +41,7 @@ export function readReferenceValueToken(text, cursor, length) {
         throw  new ParserError(i, `Input underflow while reading reference value, value so far='${text.substring(valueStart, length)}'`, text);
     }
 
-    const literal = readLiteral(text, i, length);
+    const literal = readLiteralToken(text, i, length);
 
     i = literal.end;