Call System.gc between work requests

src/main/kotlin/io/bazel/worker/CpuTimeBasedGcScheduler.kt

@@ -0,0 +1,42 @@
+package io.bazel.worker
+
+import com.sun.management.OperatingSystemMXBean
+import java.lang.management.ManagementFactory
+import java.time.Duration
+import java.util.concurrent.atomic.AtomicReference
+
+// This class is intended to mirror https://github.com/Bencodes/bazel/blob/3835d9b21ad524d06873dfbf465ffd2dfb635ba8/src/main/java/com/google/devtools/build/lib/worker/WorkRequestHandler.java#L431-L474
+class CpuTimeBasedGcScheduler(
+  /**
+   * After this much CPU time has elapsed, we may force a GC run. Set to [Duration.ZERO] to
+   * disable.
+   */
+  private val cpuUsageBeforeGc: Duration
+) {
+
+  /** The total process CPU time at the last GC run (or from the start of the worker).  */
+  private val cpuTime: Duration
+    get() = if (cpuUsageBeforeGc.isZero) Duration.ZERO else Duration.ofNanos(bean.processCpuTime)
+  private val cpuTimeAtLastGc: AtomicReference<Duration> = AtomicReference(cpuTime)
+
+  /** Call occasionally to perform a GC if enough CPU time has been used.  */
+  fun maybePerformGc() {
+    if (!cpuUsageBeforeGc.isZero) {
+      val currentCpuTime = cpuTime
+      val lastCpuTime = cpuTimeAtLastGc.get()
+      // Do GC when enough CPU time has been used, but only if nobody else beat us to it.
+      if (currentCpuTime.minus(lastCpuTime).compareTo(cpuUsageBeforeGc) > 0
+        && cpuTimeAtLastGc.compareAndSet(lastCpuTime, currentCpuTime)
+      ) {
+        System.gc()
+        // Avoid counting GC CPU time against CPU time before next GC.
+        cpuTimeAtLastGc.compareAndSet(currentCpuTime, cpuTime)
+      }
+    }
+  }
+
+  companion object {
+    /** Used to get the CPU time used by this process.  */
+    private val bean = ManagementFactory.getOperatingSystemMXBean() as OperatingSystemMXBean
+  }
+}

src/main/kotlin/io/bazel/worker/PersistentWorker.kt

@@ -41,6 +41,7 @@ import kotlinx.coroutines.runBlocking
 import kotlinx.coroutines.withContext
 import java.io.PrintStream
 import java.nio.charset.StandardCharsets.UTF_8
+import java.time.Duration
 import java.util.concurrent.Executors
 import kotlin.coroutines.CoroutineContext
 
@@ -55,11 +56,11 @@ import kotlin.coroutines.CoroutineContext
  */
 class PersistentWorker(
   private val coroutineContext: CoroutineContext,
-  private val captureIO: () -> IO
+  private val captureIO: () -> IO,
+  private val cpuTimeBasedGcScheduler: CpuTimeBasedGcScheduler,
 ) : Worker {
 
-  constructor() : this(Dispatchers.IO, IO.Companion::capture)
-
+  constructor() : this(Dispatchers.IO, IO.Companion::capture, CpuTimeBasedGcScheduler(Duration.ofSeconds(10)))
 
   @ExperimentalCoroutinesApi
   override fun start(execute: Work) = WorkerContext.run {
@@ -73,6 +74,8 @@ class PersistentWorker(
               .forEach { request ->
                 launch {
                   compileWork(request, io, writeChannel, execute)
+                  //Be a friendly worker by performing a GC between compilation requests
+                  cpuTimeBasedGcScheduler.maybePerformGc()
                 }
               }
         }.invokeOnCompletion { writeChannel.close() }