attemptGarbageCollection periodically (every N subcases)

src/common/framework/test_config.ts

@@ -4,8 +4,20 @@ export type TestConfig = {
    */
   enableDebugLogs: boolean;
 
+  /**
+   * Maximum number of subcases in flight at once, within a case. Once this many
+   * are in flight, wait for a subcase to finish before starting the next one.
+   */
   maxSubcasesInFlight: number;
+
+  /**
+   * Every `subcasesBetweenAttemptingGC` subcases, run `attemptGarbageCollection()`.
+   * Setting to `Infinity` disables this. Setting to 1 attempts GC every time (slow!).
+   */
+  subcasesBetweenAttemptingGC: number;
+
   testHeartbeatCallback: () => void;
+
   noRaceWithRejectOnTimeout: boolean;
 
   /**
@@ -41,6 +53,7 @@ export type TestConfig = {
 export const globalTestConfig: TestConfig = {
   enableDebugLogs: false,
   maxSubcasesInFlight: 100,
+  subcasesBetweenAttemptingGC: 5000,
   testHeartbeatCallback: () => {},
   noRaceWithRejectOnTimeout: false,
   unrollConstEvalLoops: false,

src/common/internal/test_group.ts

@@ -31,6 +31,7 @@ import {
   stringifyPublicParamsUniquely,
 } from '../internal/query/stringify_params.js';
 import { validQueryPart } from '../internal/query/validQueryPart.js';
+import { attemptGarbageCollection } from '../util/collect_garbage.js';
 import { DeepReadonly } from '../util/types.js';
 import { assert, unreachable } from '../util/util.js';
 
@@ -696,6 +697,7 @@ class RunCaseSpecific implements RunCase {
                   subRec.threw(ex);
                 }
               })
+              .finally(attemptGarbageCollectionIfDue)
               .finally(subcaseFinishedCallback);
 
             allPreviousSubcasesFinalizedPromise = allPreviousSubcasesFinalizedPromise.then(
@@ -711,13 +713,17 @@ class RunCaseSpecific implements RunCase {
             rec.skipped(new SkipTestCase('all subcases were skipped'));
           }
         } else {
-          await this.runTest(
-            rec,
-            sharedState,
-            this.params,
-            /* throwSkip */ false,
-            getExpectedStatus(selfQuery)
-          );
+          try {
+            await this.runTest(
+              rec,
+              sharedState,
+              this.params,
+              /* throwSkip */ false,
+              getExpectedStatus(selfQuery)
+            );
+          } finally {
+            await attemptGarbageCollectionIfDue();
+          }
         }
       } finally {
         testHeartbeatCallback();
@@ -754,3 +760,17 @@ export type CaseTimingLogLine = {
    */
   nonskippedSubcaseCount: number;
 };
+
+/** Every `subcasesBetweenAttemptingGC` calls to this function will `attemptGarbageCollection()`. */
+const attemptGarbageCollectionIfDue: () => Promise<void> = (() => {
+  // This state is global because garbage is global.
+  let subcasesSinceLastGC = 0;
+
+  return async function attemptGarbageCollectionIfDue() {
+    subcasesSinceLastGC++;
+    if (subcasesSinceLastGC >= globalTestConfig.subcasesBetweenAttemptingGC) {
+      subcasesSinceLastGC = 0;
+      return attemptGarbageCollection();
+    }
+  };
+})();