test to see if memory doubles when using map on array

Author: ellyxir

packages/runner/integration/derive_array_leak.test.ts

@@ -0,0 +1,209 @@
+#!/usr/bin/env -S deno run --allow-net --allow-env --allow-read
+
+/**
+ * Integration test to reproduce memory leak when using derive() with array.map()
+ *
+ * Bug: When a cell updates repeatedly and a derived array is created for each update,
+ * the old derived arrays are never garbage collected, causing unbounded memory growth.
+ *
+ * Expected behavior: Memory should stabilize or grow modestly
+ * Actual behavior: Memory grows by gigabytes (1GB+ per 100 increments)
+ */
+import { ANYONE, Identity, Session } from "@commontools/identity";
+import { env } from "@commontools/integration";
+import { StorageManager } from "../src/storage/cache.ts";
+import { Runtime } from "../src/index.ts";
+import { CharmManager, compileRecipe } from "@commontools/charm";
+
+(Error as any).stackTraceLimit = 100;
+
+const { API_URL } = env;
+const SPACE_NAME = "runner_integration";
+const TIMEOUT_MS = 120000; // 2 minutes to handle server restarts and settle time
+
+// Test parameters
+const INCREMENTS_PER_CLICK = 50; // How many times each click increments (must match .tsx file)
+const MAX_MEMORY_INCREASE_RATIO = 2.0; // Fail if memory more than doubles
+
+console.log("Derive Array Leak Test");
+console.log(`Connecting to: ${API_URL}`);
+console.log(`Will increment ${INCREMENTS_PER_CLICK} times in one click`);
+
+// Helper to get server process memory (portable across Linux and macOS)
+async function getServerMemoryMB(): Promise<number> {
+  // First, find the PID using pgrep (more portable than ps aux | grep)
+  const pgrepProcess = new Deno.Command("pgrep", {
+    args: ["-f", "deno run --unstable-otel"],
+    stdout: "piped",
+  });
+  const { stdout: pgrepOut, code } = await pgrepProcess.output();
+
+  if (code !== 0) {
+    throw new Error("Could not find toolshed server process (pgrep failed)");
+  }
+
+  const pid = new TextDecoder().decode(pgrepOut).trim().split("\n")[0];
+  if (!pid) {
+    throw new Error("Could not find toolshed server process");
+  }
+
+  // Then get RSS using portable ps -o format (works on Linux, macOS, BSD)
+  const psProcess = new Deno.Command("ps", {
+    args: ["-p", pid, "-o", "rss="],
+    stdout: "piped",
+  });
+  const { stdout: psOut } = await psProcess.output();
+  const rssKB = parseInt(new TextDecoder().decode(psOut).trim());
+
+  return rssKB / 1024; // Convert KB to MB
+}
+
+// Set up timeout
+const timeoutPromise = new Promise((_, reject) => {
+  setTimeout(() => {
+    reject(new Error(`Test timed out after ${TIMEOUT_MS}ms`));
+  }, TIMEOUT_MS);
+});
+
+// Main test function
+async function runTest() {
+  const account = await Identity.fromPassphrase(ANYONE);
+  const space_thingy = await account.derive(SPACE_NAME);
+  const space_thingy_space = space_thingy.did();
+  const session = {
+    private: false,
+    name: SPACE_NAME,
+    space: space_thingy_space,
+    as: space_thingy,
+  } as Session;
+
+  // Create storage manager
+  const storageManager = StorageManager.open({
+    as: session.as,
+    address: new URL("/api/storage/memory", API_URL),
+  });
+
+  // Create runtime
+  const runtime = new Runtime({
+    apiUrl: new URL(API_URL),
+    storageManager,
+  });
+
+  // Create charm manager for the specified space
+  const charmManager = new CharmManager(session, runtime);
+  await charmManager.ready;
+
+  // Read the recipe file content
+  const recipeContent = await Deno.readTextFile(
+    "./integration/derive_array_leak.test.tsx",
+  );
+
+  const recipe = await compileRecipe(
+    recipeContent,
+    "recipe",
+    runtime,
+    space_thingy_space,
+  );
+  console.log("Recipe compiled successfully");
+
+  const charm = (await charmManager.runPersistent(recipe, {})).asSchema({
+    type: "object",
+    properties: {
+      value: { type: "number" },
+      increment: {
+        asStream: true,
+      },
+    },
+    required: ["value", "increment"],
+  });
+  console.log("Charm created:", charm.entityId);
+
+  // Wait for initial state
+  await runtime.idle();
+  await runtime.storageManager.synced();
+
+  // Give it 5 seconds to settle after initialization
+  console.log("Waiting 5 seconds for memory to settle...");
+  await new Promise((resolve) => setTimeout(resolve, 5000));
+
+  // Measure baseline server memory (where the leak occurs)
+  const serverMemoryBeforeMB = await getServerMemoryMB();
+  console.log(`Baseline server memory: ${serverMemoryBeforeMB.toFixed(1)} MB`);
+  console.log(`Initial counter value: ${charm.get().value}`);
+
+  // Trigger the leak by incrementing
+  // The handler increments INCREMENTS_PER_CLICK times per click
+  console.log(
+    `Clicking increment (${INCREMENTS_PER_CLICK} increments total)...`,
+  );
+  const incrementStream = charm.key("increment");
+  incrementStream.send({});
+
+  // Wait for all updates to complete
+  console.log("Waiting for runtime to finish...");
+  await runtime.idle();
+  await runtime.storageManager.synced();
+  console.log(`Final counter value: ${charm.get().value}`);
+
+  // Verify the counter actually incremented
+  const finalValue = charm.get().value;
+  const expectedValue = INCREMENTS_PER_CLICK;
+  if (finalValue !== expectedValue) {
+    console.warn(
+      `WARNING: Counter value is ${finalValue}, expected ${expectedValue}. ` +
+        `This may indicate the derive action failed due to array size.`,
+    );
+  }
+
+  // Measure server memory after operations complete
+  const serverMemoryAfterMB = await getServerMemoryMB();
+  const serverMemoryIncreaseMB = serverMemoryAfterMB - serverMemoryBeforeMB;
+  const memoryRatio = serverMemoryAfterMB / serverMemoryBeforeMB;
+
+  console.log(`Final server memory: ${serverMemoryAfterMB.toFixed(1)} MB`);
+  console.log(
+    `Server memory increase: ${serverMemoryIncreaseMB.toFixed(1)} MB (${
+      ((memoryRatio - 1) * 100).toFixed(1)
+    }% increase)`,
+  );
+  console.log(`Memory ratio: ${memoryRatio.toFixed(2)}x`);
+
+  // Clean up
+  await runtime.dispose();
+  await storageManager.close();
+
+  // Check if server memory increase indicates a leak
+  if (memoryRatio > MAX_MEMORY_INCREASE_RATIO) {
+    console.error(
+      `FAIL: Server memory increased to ${memoryRatio.toFixed(2)}x baseline, ` +
+        `exceeds limit of ${MAX_MEMORY_INCREASE_RATIO}x`,
+    );
+    console.error("This indicates a memory leak is present");
+    throw new Error(
+      `Memory leak detected: ${
+        memoryRatio.toFixed(2)
+      }x increase (limit: ${MAX_MEMORY_INCREASE_RATIO}x)`,
+    );
+  }
+
+  console.log(
+    `PASS: Memory increase ${
+      memoryRatio.toFixed(2)
+    }x is within acceptable limit (< ${MAX_MEMORY_INCREASE_RATIO}x)`,
+  );
+  console.log(`Counter reached ${finalValue} (expected ${expectedValue})`);
+}
+
+// Run the test with timeout
+try {
+  await Promise.race([runTest(), timeoutPromise]);
+  console.log("Test completed successfully");
+  Deno.exit(0);
+} catch (error) {
+  const errorMessage = error instanceof Error ? error.message : String(error);
+  console.error("Test failed:", errorMessage);
+  if (error instanceof Error && error.stack) {
+    console.error(error.stack);
+  }
+  Deno.exit(1);
+}

packages/runner/integration/derive_array_leak.test.tsx

@@ -0,0 +1,88 @@
+/// <cts-enable />
+import {
+  Cell,
+  Default,
+  derive,
+  handler,
+  NAME,
+  recipe,
+  str,
+  Stream,
+  UI,
+} from "commontools";
+
+// How many times to increment per click
+const INCREMENTS_PER_CLICK = 50;
+
+interface RecipeState {
+  value: Default<number, 0>;
+}
+
+interface RecipeOutput {
+  value: Default<number, 0>;
+  increment: Stream<void>;
+  decrement: Stream<void>;
+}
+
+// Inline handlers to avoid import resolution issues
+const increment = handler<
+  unknown,
+  { value: Cell<number> }
+>(
+  (_args, state) => {
+    // Increment multiple times per click to trigger derive() multiple times
+    for (let i = 0; i < INCREMENTS_PER_CLICK; i++) {
+      state.value.set(state.value.get() + 1);
+    }
+  },
+);
+
+const decrement = handler<
+  unknown,
+  { value: Cell<number> }
+>(
+  (_args, state) => {
+    state.value.set(state.value.get() - 1);
+  },
+);
+
+function nth(value: number) {
+  if (value === 1) return "1st";
+  if (value === 2) return "2nd";
+  if (value === 3) return "3rd";
+  return `${value}th`;
+}
+
+function previous(value: number) {
+  return value - 1;
+}
+
+export default recipe<RecipeState, RecipeOutput>("Counter", (state) => {
+  const array = derive(state.value, (value: number) => {
+    return new Array(value).fill(0);
+  });
+  return {
+    [NAME]: str`Simple counter: ${state.value}`,
+    [UI]: (
+      <div>
+        <div>
+          <ct-button onClick={decrement(state)}>
+            dec to {previous(state.value)}
+          </ct-button>
+          <span id="counter-result">
+            Counter is the {nth(state.value)} number
+          </span>
+          <ct-button onClick={increment({ value: state.value })}>
+            inc to {state.value + 1}
+          </ct-button>
+        </div>
+        <div>
+          {array.map((v: number) => <span>{v % 10}</span>)}
+        </div>
+      </div>
+    ),
+    value: state.value,
+    increment: increment(state) as unknown as Stream<void>,
+    decrement: decrement(state) as unknown as Stream<void>,
+  };
+});