@softerist/heuristic-mcp 3.0.12 → 3.0.14

package/lib/constants.js

@@ -163,6 +163,33 @@ export const HNSWLIB_ERROR_RESET_MS = 5 * 60 * 1000; // 5 minutes
  */
 export const DEFAULT_READER_WAIT_TIMEOUT_MS = 5000;
 
+// ================================
+// Embedding Process GC Constants
+// ================================
+
+/**
+ * Default RSS threshold (MB) for adaptive GC in embedding child process.
+ */
+export const EMBEDDING_PROCESS_DEFAULT_GC_RSS_THRESHOLD_MB = 2048;
+
+/**
+ * Minimum interval (ms) between adaptive GC runs in embedding child process.
+ */
+export const EMBEDDING_PROCESS_DEFAULT_GC_MIN_INTERVAL_MS = 15_000;
+
+/**
+ * Backstop: run GC after this many requests without collection.
+ */
+export const EMBEDDING_PROCESS_DEFAULT_GC_MAX_REQUESTS_WITHOUT_COLLECTION = 8;
+
+/**
+ * Initial mutable state shape for embedding child process GC tracking.
+ */
+export const EMBEDDING_PROCESS_GC_STATE_INITIAL = Object.freeze({
+  lastRunAtMs: 0,
+  requestsSinceLastRun: 0,
+});
+
 // ================================
 // Vector Store Format Constants
 // ================================

package/lib/embed-query-process.js

@@ -31,12 +31,13 @@ function getOrCreateChild(config) {
   const args = ['--expose-gc', EMBEDDING_PROCESS_PATH];
   persistentChild = spawn(process.execPath, args, {
     stdio: ['pipe', 'pipe', 'pipe'],
-    env: {
-      ...process.env,
-      EMBEDDING_PROCESS_PERSISTENT: 'true',
-      EMBEDDING_PROCESS_VERBOSE: config.verbose ? 'true' : '',
-    },
-  });
+    env: {
+      ...process.env,
+      EMBEDDING_PROCESS_PERSISTENT: 'true',
+      EMBEDDING_PROCESS_RUN_MAIN: 'true',
+      EMBEDDING_PROCESS_VERBOSE: config.verbose ? 'true' : '',
+    },
+  });
 
   currentConfig = config;
 

package/lib/embedding-process.js

@@ -1,5 +1,11 @@
 import { pipeline } from '@huggingface/transformers';
 import { configureNativeOnnxBackend } from './onnx-backend.js';
+import {
+  EMBEDDING_PROCESS_DEFAULT_GC_MAX_REQUESTS_WITHOUT_COLLECTION,
+  EMBEDDING_PROCESS_DEFAULT_GC_MIN_INTERVAL_MS,
+  EMBEDDING_PROCESS_DEFAULT_GC_RSS_THRESHOLD_MB,
+  EMBEDDING_PROCESS_GC_STATE_INITIAL,
+} from './constants.js';
 import readline from 'readline';
 import { pathToFileURL } from 'url';
 
@@ -36,6 +42,79 @@ let configuredModel = null;
 let requestCounter = 0;
 let gcSupported = typeof global.gc === 'function';
 let nativeBackendConfigured = false;
+const gcState = { ...EMBEDDING_PROCESS_GC_STATE_INITIAL };
+
+function toPositiveNumber(value, fallback) {
+  const parsed = Number(value);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+}
+
+function toNonNegativeInteger(value, fallback) {
+  const parsed = Number.parseInt(value, 10);
+  return Number.isInteger(parsed) && parsed >= 0 ? parsed : fallback;
+}
+
+function toPositiveInteger(value, fallback) {
+  const parsed = Number.parseInt(value, 10);
+  return Number.isInteger(parsed) && parsed > 0 ? parsed : fallback;
+}
+
+function resolveGcPolicy(payload) {
+  return {
+    rssThresholdMb: toPositiveNumber(
+      payload?.gcRssThresholdMb,
+      EMBEDDING_PROCESS_DEFAULT_GC_RSS_THRESHOLD_MB
+    ),
+    minIntervalMs: toNonNegativeInteger(
+      payload?.gcMinIntervalMs,
+      EMBEDDING_PROCESS_DEFAULT_GC_MIN_INTERVAL_MS
+    ),
+    maxRequestsWithoutCollection: toPositiveInteger(
+      payload?.gcMaxRequestsWithoutCollection,
+      EMBEDDING_PROCESS_DEFAULT_GC_MAX_REQUESTS_WITHOUT_COLLECTION
+    ),
+  };
+}
+
+function maybeRunGc(policy, { reason = 'unknown', force = false } = {}) {
+  if (!gcSupported) return false;
+
+  const before = process.memoryUsage();
+  const rssBeforeMb = before.rss / 1024 / 1024;
+  const rssTrigger = rssBeforeMb >= policy.rssThresholdMb;
+  const requestTrigger = gcState.requestsSinceLastRun >= policy.maxRequestsWithoutCollection;
+
+  if (!force && !rssTrigger && !requestTrigger) {
+    return false;
+  }
+
+  const now = Date.now();
+  if (
+    !force &&
+    policy.minIntervalMs > 0 &&
+    gcState.lastRunAtMs > 0 &&
+    now - gcState.lastRunAtMs < policy.minIntervalMs
+  ) {
+    return false;
+  }
+
+  global.gc();
+  const after = process.memoryUsage();
+  gcState.lastRunAtMs = now;
+  gcState.requestsSinceLastRun = 0;
+
+  let trigger = 'forced';
+  if (!force) {
+    if (rssTrigger && requestTrigger) trigger = 'rss+requests';
+    else if (rssTrigger) trigger = 'rss';
+    else trigger = 'requests';
+  }
+
+  log(
+    `[Child:${process.pid}] GC ${reason}: trigger=${trigger} rss ${(before.rss / 1024 / 1024).toFixed(1)}MB -> ${(after.rss / 1024 / 1024).toFixed(1)}MB`
+  );
+  return true;
+}
 
 function ensureNativeBackend(threads) {
   if (nativeBackendConfigured && !threads) return;
@@ -64,6 +143,11 @@ async function getEmbedder(embeddingModel, numThreads) {
     embedderPromise = pipeline('feature-extraction', embeddingModel, {
       quantized: true,
       dtype: 'fp32',
+      session_options: {
+        numThreads,
+        intraOpNumThreads: numThreads,
+        interOpNumThreads: 1,
+      },
     }).then((model) => {
       const loadSec = ((Date.now() - loadStart) / 1000).toFixed(1);
       log(`Model ready in ${loadSec}s, ${formatMemory()}`);
@@ -88,6 +172,8 @@ function resetEmbeddingProcessState() {
   requestCounter = 0;
   currentRequestId = -1;
   nativeBackendConfigured = false;
+  gcState.lastRunAtMs = 0;
+  gcState.requestsSinceLastRun = 0;
 }
 
 /**
@@ -123,13 +209,7 @@ async function unloadModel() {
 
   // Trigger garbage collection if available
   if (gcSupported) {
-    const before = process.memoryUsage();
-    global.gc();
-    const after = process.memoryUsage();
-    log(
-      `[Child] Post-unload GC: rss ${(before.rss / 1024 / 1024).toFixed(1)}MB -> ${(after.rss / 1024 / 1024).toFixed(1)}MB, ` +
-      `heap ${(before.heapUsed / 1024 / 1024).toFixed(1)}MB -> ${(after.heapUsed / 1024 / 1024).toFixed(1)}MB`
-    );
+    maybeRunGc(resolveGcPolicy(), { reason: 'post-unload', force: true });
   }
 
   log(`[Child] Model unloaded, ${formatMemory()}`);
@@ -142,8 +222,18 @@ async function runEmbedding(payload) {
     chunks = [],
     numThreads = 1,
     batchSize = null,
+    enableExplicitGc = true,
+    gcRssThresholdMb = EMBEDDING_PROCESS_DEFAULT_GC_RSS_THRESHOLD_MB,
+    gcMinIntervalMs = EMBEDDING_PROCESS_DEFAULT_GC_MIN_INTERVAL_MS,
+    gcMaxRequestsWithoutCollection = EMBEDDING_PROCESS_DEFAULT_GC_MAX_REQUESTS_WITHOUT_COLLECTION,
     requestId = null,
   } = payload || {};
+  const shouldRunGc = enableExplicitGc !== false && gcSupported;
+  const gcPolicy = resolveGcPolicy({
+    gcRssThresholdMb,
+    gcMinIntervalMs,
+    gcMaxRequestsWithoutCollection,
+  });
 
   if (!embeddingModel) {
     throw new Error('Missing embeddingModel');
@@ -157,6 +247,9 @@ async function runEmbedding(payload) {
   const results = [];
   let disposeCount = 0;
   const start = Date.now();
+  if (shouldRunGc) {
+    gcState.requestsSinceLastRun += 1;
+  }
 
   // Batch embedding - tunable for throughput vs memory tradeoffs
   // FORCE BATCH_SIZE = 1 to restore 1.0 files/s speed (batching adds overhead on CPU)
@@ -244,13 +337,10 @@ async function runEmbedding(payload) {
       );
     }
 
-    // Trigger GC every 100 chunks to reduce overhead (was 40)
-    if (batchEnd % 100 === 0 && typeof global.gc === 'function') {
-      global.gc();
-      const elapsed = ((Date.now() - start) / 1000).toFixed(1);
-      log(
-        `[Child:${process.pid}] Request ${reqId}: GC triggered after ${batchEnd}/${chunks.length} chunks in ${elapsed}s, ${formatMemory()}`
-      );
+    if (shouldRunGc && (batchEnd % 20 === 0 || batchEnd === chunks.length)) {
+      maybeRunGc(gcPolicy, {
+        reason: `request ${reqId} progress ${batchEnd}/${chunks.length}`,
+      });
     }
   }
 
@@ -258,13 +348,8 @@ async function runEmbedding(payload) {
   log(
     `[Child:${process.pid}] Request ${reqId}: done ${results.length} chunks in ${totalSec}s, ${disposeCount} tensors disposed, ${formatMemory()}`
   );
-  if (gcSupported) {
-    const before = process.memoryUsage();
-    global.gc();
-    const after = process.memoryUsage();
-    log(
-      `[Child:${process.pid}] Request ${reqId}: GC rss ${(before.rss / 1024 / 1024).toFixed(1)}MB -> ${(after.rss / 1024 / 1024).toFixed(1)}MB`
-    );
+  if (shouldRunGc) {
+    maybeRunGc(gcPolicy, { reason: `request ${reqId} end` });
   }
   const usage = process.memoryUsage();
   return {
@@ -337,12 +422,13 @@ async function main() {
   process.stdout.write(JSON.stringify(output));
 }
 
-function shouldRunMain() {
-  if (process.env.VITEST) return false;
-  if (!process.argv[1]) return false;
-  const entryUrl = pathToFileURL(process.argv[1]).href;
-  return import.meta.url === entryUrl;
-}
+function shouldRunMain() {
+  if (process.env.EMBEDDING_PROCESS_RUN_MAIN === 'true') return true;
+  if (process.env.VITEST) return false;
+  if (!process.argv[1]) return false;
+  const entryUrl = pathToFileURL(process.argv[1]).href;
+  return import.meta.url === entryUrl;
+}
 
 if (shouldRunMain()) {
   main().catch((err) => {