Don't request a GC before waiting on the entry point

src/jsc/VirtualMachine.rs

@@ -2824,8 +2824,6 @@ impl VirtualMachine {
 
         // pending_internal_promise can change if hot module reloading is enabled
         if self.is_watcher_enabled() {
-            // accessed here (no overlapping `&mut EventLoop`).
-            self.event_loop_mut().perform_gc();
             loop {
                 let Some(p) = self.pending_internal_promise else {
                     break;
@@ -2848,7 +2846,6 @@ impl VirtualMachine {
             if crate::JSPromise::status_ptr(promise) == crate::js_promise::Status::Rejected {
                 return Ok(promise);
             }
-            self.event_loop_mut().perform_gc();
             let _ = self.wait_for_promise(jsc::AnyPromise::Internal(promise));
         }
 
@@ -4888,7 +4885,6 @@ impl VirtualMachine {
         entry_path: &[u8],
     ) -> crate::CrateResult<*mut JSInternalPromise> {
         let promise = self.reload_entry_point(entry_path)?;
-        self.event_loop_mut().perform_gc();
         self.event_loop_mut()
             .wait_for_worker_entry_evaluation(jsc::AnyPromise::Internal(promise));
         if let Some(worker) = self.worker_ref() {
@@ -4908,7 +4904,6 @@ impl VirtualMachine {
 
         // pending_internal_promise can change if hot module reloading is enabled
         if self.is_watcher_enabled() {
-            self.event_loop_mut().perform_gc();
             loop {
                 let Some(p) = self.pending_internal_promise else {
                     break;
@@ -4931,7 +4926,6 @@ impl VirtualMachine {
             if crate::JSPromise::status_ptr(promise) == crate::js_promise::Status::Rejected {
                 return Ok(promise);
             }
-            self.event_loop_mut().perform_gc();
             let _ = self.wait_for_promise(jsc::AnyPromise::Internal(promise));
         }
 

src/jsc/bindings/BunProcess.cpp

@@ -4103,12 +4103,17 @@ JSC_DEFINE_HOST_FUNCTION(Process_functionMemoryUsage, (JSC::JSGlobalObject * glo
     //    arrayBuffers: 9386
     // }
 
+    size_t heapTotal = vm.heap.blockBytesAllocated();
     result->putDirectOffset(vm, 0, JSC::jsNumber(current_rss));
-    result->putDirectOffset(vm, 1, JSC::jsNumber(vm.heap.blockBytesAllocated()));
+    result->putDirectOffset(vm, 1, JSC::jsNumber(heapTotal));
 
     // heap.size() walks every block of the heap, so report the size JSC measured
-    // at the end of the most recent collection instead.
-    result->putDirectOffset(vm, 2, JSC::jsNumber(WebCore::clientData(vm)->heapSizeAfterLastCollection()));
+    // at the end of the most recent collection instead. Nothing requests a
+    // collection while Bun starts up, and until the first one nothing has been
+    // freed either, so the whole heap counts as used. (external is measured by
+    // collections too and stays 0 until then.)
+    size_t heapUsed = WebCore::clientData(vm)->heapSizeAfterLastCollection();
+    result->putDirectOffset(vm, 2, JSC::jsNumber(heapUsed ? heapUsed : heapTotal));
 
     result->putDirectOffset(vm, 3, JSC::jsNumber(vm.heap.extraMemorySize() + vm.heap.externalMemorySize()));
 

src/runtime/jsc_hooks.rs

@@ -853,8 +853,6 @@ unsafe fn load_preloads(vm: *mut VirtualMachine) -> bun_jsc::CrateResult<*mut JS
                 // enabled.
                 // SAFETY: `el` is the live per-thread event loop.
                 let el = unsafe { &*vm }.event_loop();
-                // SAFETY: `el` is the live per-thread event loop.
-                unsafe { (*el).perform_gc() };
                 loop {
                     // SAFETY: `pending_internal_promise` was set just above (or
                     // swapped by HMR to another live cell); `status()` is a
@@ -878,8 +876,6 @@ unsafe fn load_preloads(vm: *mut VirtualMachine) -> bun_jsc::CrateResult<*mut JS
                     }
                 }
             } else {
-                // SAFETY: `el` is the live per-thread event loop.
-                unsafe { (*(*vm).event_loop()).perform_gc() };
                 // SAFETY: per fn contract — short-lived `&mut *vm`; `promise` is a
                 // live protected JSC heap cell.
                 let _ = unsafe { (*vm).wait_for_promise(AnyPromise::Internal(promise)) };

test/js/bun/gc/gc-controller-cadence.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, test } from "bun:test";
-import { bunEnv, bunExe, isDebug } from "harness";
+import { bunEnv, bunExe, isDebug, tempDir } from "harness";
 
 // Bun's GarbageCollectionController used to sample `blockBytesAllocated +
 // extraMemorySize` on every event-loop tick and arm a 16 ms one-shot whenever
@@ -55,6 +55,77 @@ async function countEdenCollections(
   return { eden };
 }
 
+// Bun used to request a collection (`perform_gc()`) right before waiting on the
+// entry point's promise, once more per preload, and again for a worker's entry
+// point. The heap holds little more than the fresh global object at that point,
+// so JSC served each request as an eden collection that freed nothing, on the
+// main thread, before the first line of the program ran. These programs are too
+// small to reach JSC's own allocation budget, so any eden collection JSC logs
+// was requested by Bun. The full collections Bun runs on purpose are left out:
+// tearing the VM down at exit (BUN_DESTRUCT_VM_ON_EXIT, which the ASAN lanes
+// set), and, for a worker, once after its entry point ran and once at teardown.
+describe.concurrent("no collection is requested while starting up", () => {
+  const env = {
+    ...bunEnv,
+    // The startup requests and the idle timer both go through
+    // GarbageCollectionController::perform_gc(), so BUN_GC_TIMER_DISABLE would
+    // hide the requests too. Instead keep the timer from firing while a slow
+    // (debug, ASAN) child is still starting its worker.
+    BUN_GC_TIMER_DISABLE: undefined,
+    BUN_GC_TIMER_INTERVAL: String(2 ** 31 - 1),
+    // The CI runner sets 1, which makes some test-runner paths request collections.
+    BUN_GARBAGE_COLLECTOR_LEVEL: "0",
+    BUN_JSC_logGC: "true",
+  };
+
+  // `ran` is what the program prints once the code under test has run.
+  async function edenCollectionsLoggedBy(cmd: string[], cwd?: string, ran = "entry ran") {
+    await using proc = Bun.spawn({ cmd, cwd, env, stdout: "pipe", stderr: "pipe" });
+    const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]);
+    const log = stdout + stderr;
+    expect(log).toContain(ran);
+    expect(exitCode, log).toBe(0);
+    return log.match(/=> EdenCollection/g) ?? [];
+  }
+
+  test("running a script", async () => {
+    expect(await edenCollectionsLoggedBy([bunExe(), "-e", `console.log("entry ran")`])).toEqual([]);
+  });
+
+  test("running a script with a preload", async () => {
+    using dir = tempDir("gc-startup-preload", {
+      "preload.js": `globalThis.preloaded = true;`,
+      "entry.js": `console.log("entry ran", globalThis.preloaded);`,
+    });
+    const cmd = [bunExe(), "--preload", "./preload.js", "entry.js"];
+    expect(await edenCollectionsLoggedBy(cmd, String(dir), "entry ran true")).toEqual([]);
+  });
+
+  test("running a test file", async () => {
+    using dir = tempDir("gc-startup-test", {
+      "entry.test.js": `
+        import { test } from "bun:test";
+        test("entry ran", () => {});
+      `,
+    });
+    expect(await edenCollectionsLoggedBy([bunExe(), "test", "./entry.test.js"], String(dir))).toEqual([]);
+  });
+
+  test("starting a worker", async () => {
+    using dir = tempDir("gc-startup-worker", {
+      "entry.js": `
+        const worker = new Worker(new URL("./worker.js", import.meta.url).href);
+        worker.onmessage = ({ data }) => {
+          console.log(data);
+          worker.terminate();
+        };
+      `,
+      "worker.js": `postMessage("entry ran");`,
+    });
+    expect(await edenCollectionsLoggedBy([bunExe(), "entry.js"], String(dir))).toEqual([]);
+  });
+});
+
 describe.skipIf(isDebug)("GarbageCollectionController eden cadence", () => {
   // 100 ticks allocating ~50 KB each is ~5 MB total over ~2 s. Before the fix
   // this produced ~128 eden collections (one per ~16 ms of wall time). With the

test/js/node/process/process.test.js

@@ -1095,6 +1095,15 @@
       expect(full).toBeGreaterThan(0);
       expect(heapUsed).toBe(full);
     });
+
+    // Nothing requests a collection while Bun starts up, so there is no figure
+    // yet. Nothing has been freed yet either, so the whole heap counts as used.
+    it("counts the whole heap as used before the first collection", async () => {
+      const { heapTotal, heapUsed } = await reportedBy(`console.log(JSON.stringify(process.memoryUsage()))`);
+
+      expect(heapTotal).toBeGreaterThan(0);
+      expect(heapUsed).toBe(heapTotal);
+    });
   });
 
   describe("process.cpuUsage", () => {

test/js/web/abort/abort.test.ts

@@ -309,6 +309,10 @@ describe.concurrent("AbortSignal.timeout() still fires after its observers go aw
       const { heapStats } = require("bun:jsc");
       const wrappers = () => heapStats().objectTypeCounts.AbortSignal ?? 0;
       const N = 32;
+      // Nothing has collected yet in a fresh process, and heapStats() collects
+      // itself in that case, which would collect the wrappers in the middle of
+      // counting them. Collect up front so the two counts below are comparable.
+      Bun.gc(true);
       // A full GC of the debug heap takes ~100ms under ASAN; the deadline only
       // has to come after it.
       const deadline = 1000;