@coherentglobal/wasm-runner 0.1.4 → 0.2.4

package/dist/node/threads/workerThread.ts

@@ -1,21 +1,12 @@
-import { isMainThread, parentPort } from "worker_threads";
-import { createId as cuid } from "@paralleldrive/cuid2";
+import { isMainThread, parentPort, threadId } from "worker_threads";
 import { ThreadWorker } from "poolifier";
 import { THREAD_EVENT_TYPES } from "../../constants";
 
-import type { TaskFunctions, TaskFunction, WorkerOptions } from "poolifier";
 import type { EVENT_TYPE, EventRequestData } from "../../types";
 
-class WorkerThread extends ThreadWorker {
-  constructor(
-    taskFunctions:
-      | TaskFunction<unknown, Response>
-      | TaskFunctions<unknown, Response>,
-    opts?: WorkerOptions
-  ) {
-    super(taskFunctions, opts);
-  }
+const activeListeners = new Map();
 
+class WorkerThread extends ThreadWorker {
   /**
    * Sends message back to the main thread.
    *
@@ -43,6 +34,16 @@ class WorkerThread extends ThreadWorker {
     }
   }
 
+  private cleanupListener = (eventId) => {
+    setTimeout(() => {
+      const listener = activeListeners.get(eventId);
+      if (listener) {
+        parentPort.off("message", listener);
+        activeListeners.delete(eventId);
+      }
+    });
+  };
+
   /**
    * Sends a request to the main thread and waits for a response.
    *
@@ -54,30 +55,32 @@ class WorkerThread extends ThreadWorker {
    */
   async requestMessage(payload: any, context: any) {
     return new Promise((resolve, reject) => {
-      const eventId = cuid();
-
       // Send the request to parent
       this.postMessage({
         payload,
         context,
         type: THREAD_EVENT_TYPES.REQUEST_EXECUTE as EVENT_TYPE,
-        eventId,
+        threadId,
       });
 
       // Receive the response from parent once ready
-      this.onMessage((message: EventRequestData) => {
-        if (
-          message.eventId === eventId &&
-          message?.type === THREAD_EVENT_TYPES.RESPONSE
-        ) {
+      const messageListener = (message: EventRequestData) => {
+        parentPort.off("message", messageListener);
+        if (message?.type === THREAD_EVENT_TYPES.RESPONSE) {
           resolve(message?.payload);
-        } else if (
-          message.eventId === eventId &&
-          message?.type === THREAD_EVENT_TYPES.ERROR
-        ) {
+        } else if (message?.type === THREAD_EVENT_TYPES.ERROR) {
           reject(message?.payload);
         }
-      });
+      };
+      this.onMessage(messageListener);
+    });
+  }
+
+  reportStats(payload: any) {
+    this.postMessage({
+      payload,
+      type: THREAD_EVENT_TYPES.STATS_REPORT as EVENT_TYPE,
+      threadId,
     });
   }
 }

package/dist/node.d.ts

@@ -1,6 +1,7 @@
 import tmp from "tmp";
-import type { FixedThreadPool } from "./node/threads/workerPool";
-import type { NodeModel, RunnerConfig, ModelConfig, ResponseObject } from "./types";
+import EventEmitter from "events";
+import { BaseLogger } from "pino";
+import { NodeModel, RunnerConfig, ModelConfig, ResponseObject, Compatibility, WasmOptions, ModelInstance } from "./types";
 import { CancellationToken } from "./CancellationToken";
 export { ColumnarSerializer } from "./serializer/columnarSerializer";
 export { CancellationToken } from "./CancellationToken";
@@ -11,19 +12,22 @@ export { ModelExecuteCancelled } from "./error";
  * @class
  * @classdesc WasmRunner class, responsible for managing model and it's lifecycle
  */
-export declare class WasmRunner {
+export declare class WasmRunner extends EventEmitter {
     _tempWorkerFolder: tmp.DirResult;
     _tempModelFolder: tmp.DirResult;
     license: string;
     models: any[];
     externalResolverModule: any;
     initializingModels: string[];
+    options: WasmOptions;
+    safeCompiler: string;
+    logger: BaseLogger;
     /**
      * Create new Wasm Runner instance
      *
      * @param {RunnerConfig} wasmRunnerConfig
      */
-    constructor(wasmRunnerConfig?: RunnerConfig, externalResolverModule?: string, license?: string);
+    constructor(wasmRunnerConfig?: RunnerConfig, externalResolverModule?: string, options?: any, license?: string);
     /**
      * Initialize wasm runner fetching model from remote server
      *
@@ -31,9 +35,9 @@ export declare class WasmRunner {
      * @function initialize
      */
     initialize(license?: string): Promise<void>;
-    _createModelInstance(id: any, url: any, workerFolder: any, size: any): Promise<FixedThreadPool<any, any>>;
+    _createModelInstance(id: any, url: any, workerFolder: any, size?: number): Promise<ModelInstance>;
     _initializeModelInstance(m: NodeModel): Promise<void>;
-    _createModelInstanceFromURL(id: string, url: string, workerFolder: string, modelFolder: string, size: number): Promise<FixedThreadPool<any, any>>;
+    _createModelInstanceFromURL(id: string, url: string, workerFolder: string, modelFolder: string, size: number): Promise<ModelInstance>;
     /**
      * Append and initialize model in preparation for the `execute()`.
      *
@@ -52,14 +56,32 @@ export declare class WasmRunner {
      * @returns {Promise<void>}
      */
     remove(id: string): Promise<void>;
-    _parseError(rawResponse: any): Object;
+    _parseError(rawResponse: any): object;
     _getModel(id: string): NodeModel;
+    getModelSize(id: string): number;
+    getModelCompilerVersion(id: any): string;
     /**
      * Check if model existed
      * @param {string} id Model id
      * @returns {boolean}
      */
     isExist(id: string): boolean;
+    isModelCompatible(model: any, input: any): boolean;
+    getModelsStats(): {
+        thread_stats: any;
+        memory_usage_mb: any;
+        uptime_ms: number;
+        min_time_ms: any;
+        mean_time_ms: any;
+        p95_time_ms: any;
+        p99_time_ms: any;
+        max_time_ms: any;
+        busy: any;
+        size: any;
+        id: any;
+    }[];
+    private getPartiallyCompatibleMessage;
+    private getIncompatibleMessage;
     /**
      * Perform calculation. The runner will use request_meta.version_uuid of input argument to locate model
      * @async
@@ -67,4 +89,7 @@ export declare class WasmRunner {
      * @returns {Promise<ResponseObject>} - Response model data
      */
     execute(input: any, id?: string, raw?: boolean, cancelToken?: CancellationToken): Promise<ResponseObject>;
+    getNeuronCompilerVersion(logFile: any): Promise<any>;
+    checkCompilerVersionCompatibility(modelCompilerVersion: string): Promise<Compatibility>;
+    getSafeCompilerVersion(runnerVersion: string): any;
 }