some decorator attempt and stuff

Author: axmmisaka

src/benchmark/Sieve.ts

@@ -9,7 +9,8 @@ import {
   App,
   TimeValue,
   Origin,
-  Log
+  Log,
+  GraphDebugLogger
 } from "../core/internal";
 
 Log.global.level = Log.levels.INFO;
@@ -97,6 +98,7 @@ class Filter extends Reactor {
                 // console.log("CREATED: " + x._getFullyQualifiedName())
                 // FIXME: weird hack. Maybe just accept writable ports as well?
                 const port = (out as unknown as WritablePort<number>).getPort();
+                console.log("connecting......");
                 this.connect(port, n.inp);
                 // FIXME: this updates the dependency graph, but it doesn't redo the topological sort
                 // For a pipeline like this one, it is not necessary, but in general it is.
@@ -133,5 +135,10 @@ class Sieve extends App {
   }
 }
 
+
 const sieve = new Sieve("Sieve");
+
+globalThis.graphDebugLogger = new GraphDebugLogger(sieve);
+globalThis.recording = false;
+
 sieve._start();

src/core/graph.ts

@@ -3,9 +3,43 @@
  * @author Marten Lohstroh <[email protected]>
  */
 
+import { DebugLogger } from "util";
 import {Reaction} from "./reaction";
 import type {Sortable, Variable} from "./types";
-import {Log} from "./util";
+import {GraphDebugLogger, Log} from "./util";
+
+
+// eslint-disable-next-line @typescript-eslint/explicit-function-return-type, @typescript-eslint/no-explicit-any
+const debugLoggerDecorator = (target: any, context: ClassMethodDecoratorContext) => {
+  if (context.kind === "method") {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return function (this: any, ...args: unknown[]): any {
+      console.log(`${context.name.toString()} is called.`);
+      console.log(`Tracestack: ${(new Error()).stack}`);
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
+      return target.call(this, ...args);
+    }
+  }
+}
+
+declare global {
+  var graphDebugLogger: GraphDebugLogger | undefined;
+  var recording: boolean;
+}
+
+const debugHelper = (): void => {
+  if (globalThis.recording) { return; }
+  globalThis.recording = true;
+  if (globalThis.graphDebugLogger == null) {
+    return
+  }
+
+  const err = new Error();
+  console.log(err.stack);
+  const debuglogger = globalThis.graphDebugLogger;
+  debuglogger.capture(err);
+  globalThis.recording = false;
+};
 
 /**
  * A generic precedence graph.
@@ -53,6 +87,7 @@ export class PrecedenceGraph<T> {
    * @param node
    */
   addNode(node: T): void {
+    debugHelper();
     if (!this.adjacencyMap.has(node)) {
       this.adjacencyMap.set(node, new Set());
     }
@@ -143,6 +178,8 @@ export class PrecedenceGraph<T> {
    * @param downstream The node at which the directed edge ends.
    */
   addEdge(upstream: T, downstream: T): void {
+    debugHelper();
+    console.log("!");
     const deps = this.adjacencyMap.get(downstream);
     if (deps == null) {
       this.adjacencyMap.set(downstream, new Set([upstream]));

src/core/util.ts

@@ -1,5 +1,8 @@
 import ULog from "ulog";
-import { readFileSync } from 'fs';
+import { TimeValue } from "./time";
+import { Component } from "./component";
+import { Reactor } from "./reactor";
+import fs from 'fs';
 
 /**
  * Utilities for the reactor runtime.
@@ -185,4 +188,36 @@ export class Log {
     }
   }
 }
+interface runtimeLog {
+  time: TimeValue,
+  graphMermaidString: string,
+  stacktrace: string,
+}
+
+export class GraphDebugLogger {
+  logs: runtimeLog[];
+  rootReactor: Reactor;
+
+  constructor(rootReactor: Reactor) {
+    this.logs = [];
+    this.rootReactor = rootReactor;
+  }
 
+  public capture(stacktrace?: Error): void {
+    const hierarchy = this.rootReactor._getNodeHierarchyLevels();
+    // _getPrecedenceGraph is private
+    const graph = this.rootReactor["_getPrecedenceGraph"]();
+    const str = graph.toMermaidString(undefined, hierarchy);
+    const time = this.rootReactor["util"].getElapsedLogicalTime();
+    this.logs.push({
+      time,
+      graphMermaidString: str,
+      stacktrace: stacktrace?.stack ?? "unknown"
+    });
+  }
+
+  public write(filepath: string): void {
+    // Blocking
+    fs.appendFileSync(filepath, JSON.stringify(this.logs), {flag: "a+"});
+  }
+}