Instead of a single event for NodeExecution, add NodeExecutionStart and NodeExecutionEnd

examples/exec-graph/src/index.ts

@@ -11,7 +11,6 @@ import {
   registerCoreProfile,
   registerSceneProfile,
   Registry,
-  traceToLogger,
   validateGraph,
   validateRegistry,
   writeGraphToJSON
@@ -69,7 +68,12 @@ async function execGraph({
   const engine = new Engine(graph);
 
   if (programOptions.trace) {
-    engine.onNodeExecution.addListener(traceToLogger);
+    engine.onNodeExecutionStart.addListener((node) =>
+      Logger.verbose(`<< ${node.description.typeName}:${node.id} >> START`)
+    );
+    engine.onNodeExecutionEnd.addListener((node) =>
+      Logger.verbose(`<< ${node.description.typeName}:${node.id} >> END`)
+    );
   }
 
   if (programOptions.dryRun) {

packages/core/src/Execution/Engine.ts

@@ -15,7 +15,8 @@ export class Engine {
   private readonly fiberQueue: Fiber[] = [];
   public readonly asyncNodes: AsyncNode[] = [];
   public readonly eventNodes: EventNode[] = [];
-  public readonly onNodeExecution = new EventEmitter<Node>();
+  public readonly onNodeExecutionStart = new EventEmitter<Node>();
+  public readonly onNodeExecutionEnd = new EventEmitter<Node>();
   public executionSteps = 0;
 
   constructor(public readonly graph: Graph) {
@@ -27,10 +28,15 @@ export class Engine {
     });
     // init all event nodes at startup
     this.eventNodes.forEach((eventNode) => {
+      // evaluate input parameters
       eventNode.inputSockets.forEach((inputSocket) => {
-        resolveSocketValue(this.graph, inputSocket);
+        Assert.mustBeTrue(inputSocket.valueTypeName !== 'flow');
+        resolveSocketValue(this, inputSocket);
       });
+
+      this.onNodeExecutionStart.emit(eventNode);
       eventNode.init(this);
+      this.onNodeExecutionEnd.emit(eventNode);
     });
   }
 

packages/core/src/Execution/Fiber.ts

@@ -82,25 +82,27 @@ export class Fiber {
 
     node.inputSockets.forEach((inputSocket) => {
       if (inputSocket.valueTypeName !== 'flow') {
-        resolveSocketValue(this.graph, inputSocket);
+        resolveSocketValue(this.engine, inputSocket);
       }
     });
 
     // first resolve all input values
     // flow socket is set to true for the one flowing in, while all others are set to false.
-    this.engine.onNodeExecution.emit(node);
+    this.engine.onNodeExecutionStart.emit(node);
     if (node instanceof AsyncNode) {
       this.engine.asyncNodes.push(node);
       node.triggered(this.engine, link.socketName, () => {
         // remove from the list of pending async nodes
         const index = this.engine.asyncNodes.indexOf(node);
         this.engine.asyncNodes.splice(index, 1);
+        this.engine.onNodeExecutionEnd.emit(node);
         this.executionSteps++;
       });
       return;
     }
     if (node instanceof FlowNode) {
       node.triggered(this, link.socketName);
+      this.engine.onNodeExecutionEnd.emit(node);
       this.executionSteps++;
       return;
     }

packages/core/src/Execution/resolveSocketValue.ts

@@ -1,15 +1,17 @@
 import { Assert } from '../Diagnostics/Assert';
-import { Graph } from '../Graphs/Graph';
 import { ImmediateNode } from '../Nodes/ImmediateNode';
 //import { ImmediateNode } from '../Nodes/ImmediateNode';
 import { Socket } from '../Sockets/Socket';
+import { Engine } from './Engine';
 
-export function resolveSocketValue(graph: Graph, inputSocket: Socket) {
+export function resolveSocketValue(engine: Engine, inputSocket: Socket) {
   // if it has no links, leave value on input socket alone.
   if (inputSocket.links.length === 0) {
     return;
   }
 
+  const graph = engine.graph;
+
   const upstreamLink = inputSocket.links[0];
   // caching the target node + socket here increases engine performance by 8% on average.  This is a hotspot.
   if (
@@ -44,10 +46,12 @@ export function resolveSocketValue(graph: Graph, inputSocket: Socket) {
     // resolve all inputs for the upstream node (this is where the recursion happens)
     // TODO: This is a bit dangerous as if there are loops in the graph, this will blow up the stack
     for (const upstreamInputSocket of upstreamNode.inputSockets) {
-      resolveSocketValue(graph, upstreamInputSocket);
+      resolveSocketValue(engine, upstreamInputSocket);
     }
 
+    engine.onNodeExecutionStart.emit(upstreamNode);
     upstreamNode.exec();
+    this.engine.onNodeExecutionEnd.emit(upstreamNode);
 
     // get the output value we wanted.
     inputSocket.value = upstreamOutputSocket.value;

packages/core/src/Nodes/Registry/NodeTypeRegistry.ts

@@ -15,7 +15,6 @@ export class NodeTypeRegistry {
       description.otherTypeNames
         .concat([description.typeName])
         .forEach((typeName) => {
-          console.log('typeName', typeName);
           if (typeName in this.typeNameToNodeDescriptions) {
             throw new Error(
               `already registered node type ${typeName} (string)`

packages/core/src/index.ts

@@ -23,7 +23,6 @@ export * from './Nodes/Templates/In0Out1FuncNode';
 
 // loading & execution
 export * from './Execution/Engine';
-export * from './Execution/traceToLogger';
 export * from './Graphs/IO/readGraphFromJSON';
 export * from './Graphs/IO/writeGraphToJSON';
 export * from './Graphs/IO/writeNodeSpecsToJSON';