Collect the number of bytes collected by GC and expose it via the BEP.

Roll forward of bazelbuild@3678bb5.

Instead of collecting the cumulative number of bytes, collect it per type of GC
space.

PiperOrigin-RevId: 397926469

src/main/java/com/google/devtools/build/lib/buildeventstream/proto/build_event_stream.proto

@@ -873,6 +873,16 @@ message BuildMetrics {
     // Size of the peak JVM heap size in bytes post GC. Note that this reports 0
     // if there was no major GC during the build.
     int64 peak_post_gc_heap_size = 2;
+
+    message GarbageMetrics {
+      // Type of garbage collected, e.g. G1 Old Gen.
+      string type = 1;
+      // Number of bytes of garbage of the given type collected during this
+      // invocation.
+      int64 garbage_collected = 2;
+    }
+
+    repeated GarbageMetrics garbage_metrics = 3;
   }
   MemoryMetrics memory_metrics = 2;
 

src/main/java/com/google/devtools/build/lib/metrics/MetricsCollector.java

@@ -32,6 +32,7 @@
 import com.google.devtools.build.lib.buildeventstream.BuildEventStreamProtos.BuildMetrics.BuildGraphMetrics;
 import com.google.devtools.build.lib.buildeventstream.BuildEventStreamProtos.BuildMetrics.CumulativeMetrics;
 import com.google.devtools.build.lib.buildeventstream.BuildEventStreamProtos.BuildMetrics.MemoryMetrics;
+import com.google.devtools.build.lib.buildeventstream.BuildEventStreamProtos.BuildMetrics.MemoryMetrics.GarbageMetrics;
 import com.google.devtools.build.lib.buildeventstream.BuildEventStreamProtos.BuildMetrics.PackageMetrics;
 import com.google.devtools.build.lib.buildeventstream.BuildEventStreamProtos.BuildMetrics.TargetMetrics;
 import com.google.devtools.build.lib.buildeventstream.BuildEventStreamProtos.BuildMetrics.TimingMetrics;
@@ -49,6 +50,7 @@
 import com.google.devtools.build.skyframe.SkyframeGraphStatsEvent;
 import java.time.Duration;
 import java.util.Comparator;
+import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.concurrent.atomic.AtomicLong;
@@ -260,6 +262,14 @@ private MemoryMetrics createMemoryMetrics() {
       // notification (which may arrive too late for this specific GC).
       memoryMetrics.setPeakPostGcHeapSize(usedHeapSizePostBuild);
     }
+
+    Map<String, Long> garbageStats = PostGCMemoryUseRecorder.get().getGarbageStats();
+    for (Map.Entry<String, Long> garbageEntry : garbageStats.entrySet()) {
+      GarbageMetrics.Builder garbageMetrics = GarbageMetrics.newBuilder();
+      garbageMetrics.setType(garbageEntry.getKey()).setGarbageCollected(garbageEntry.getValue());
+      memoryMetrics.addGarbageMetrics(garbageMetrics.build());
+    }
+
     return memoryMetrics.build();
   }
 

src/main/java/com/google/devtools/build/lib/metrics/PostGCMemoryUseRecorder.java

@@ -18,6 +18,7 @@
 import com.google.common.annotations.VisibleForTesting;
 import com.google.common.base.Supplier;
 import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
 import com.google.common.flogger.GoogleLogger;
 import com.google.devtools.build.lib.analysis.config.BuildConfiguration;
 import com.google.devtools.build.lib.profiler.Profiler;
@@ -34,9 +35,11 @@
 import com.google.devtools.common.options.OptionsBase;
 import com.google.devtools.common.options.OptionsParsingResult;
 import com.sun.management.GarbageCollectionNotificationInfo;
+import com.sun.management.GcInfo;
 import java.lang.management.GarbageCollectorMXBean;
 import java.lang.management.ManagementFactory;
 import java.lang.management.MemoryUsage;
+import java.util.HashMap;
 import java.util.Map;
 import java.util.Optional;
 import javax.annotation.concurrent.GuardedBy;
@@ -94,6 +97,9 @@ static PeakHeap create(long bytes, long timestampMillis) {
   @GuardedBy("this")
   private boolean memoryUsageReportedZero = false;
 
+  @GuardedBy("this")
+  private Map<String, Long> garbageStats = new HashMap<>();
+
   @VisibleForTesting
   PostGCMemoryUseRecorder(Iterable<GarbageCollectorMXBean> mxBeans) {
     for (GarbageCollectorMXBean mxBean : mxBeans) {
@@ -114,9 +120,17 @@ public synchronized boolean wasMemoryUsageReportedZero() {
     return memoryUsageReportedZero;
   }
 
+  /**
+   * Returns the number of bytes garbage collected during this invocation. Broken down by GC space.
+   */
+  public synchronized ImmutableMap<String, Long> getGarbageStats() {
+    return ImmutableMap.copyOf(garbageStats);
+  }
+
   public synchronized void reset() {
     peakHeap = Optional.empty();
     memoryUsageReportedZero = false;
+    garbageStats = new HashMap<>();
   }
 
   private synchronized void updatePostGCHeapMemoryUsed(long used, long timestampMillis) {
@@ -139,6 +153,26 @@ public void handleNotification(Notification notification, Object handback) {
 
     GarbageCollectionNotificationInfo info =
         GarbageCollectionNotificationInfo.from((CompositeData) notification.getUserData());
+
+    Map<String, Long> gcBefore = new HashMap<>();
+    GcInfo gcInfo = info.getGcInfo();
+    for (Map.Entry<String, MemoryUsage> memoryUsage : gcInfo.getMemoryUsageBeforeGc().entrySet()) {
+      String kind = memoryUsage.getKey();
+      gcBefore.put(kind, memoryUsage.getValue().getUsed());
+    }
+    synchronized (this) {
+      for (Map.Entry<String, MemoryUsage> memoryUsage : gcInfo.getMemoryUsageAfterGc().entrySet()) {
+        String kind = memoryUsage.getKey();
+        long before = gcBefore.containsKey(kind) ? gcBefore.get(kind) : 0;
+        long diff = before - memoryUsage.getValue().getUsed();
+        // The difference is potentially negative when the JVM propagates objects from one GC space
+        // to another. Discard these cases.
+        if (diff > 0) {
+          garbageStats.compute(kind, (k, v) -> v == null ? diff : v + diff);
+        }
+      }
+    }
+
     if (wasStopTheWorldGc(info)) {
       long durationNs = info.getGcInfo().getDuration() * 1_000_000;
       long end = Profiler.nanoTimeMaybe();

src/test/java/com/google/devtools/build/lib/metrics/BUILD

@@ -20,6 +20,7 @@ java_test(
         "//src/main/java/com/google/devtools/build/lib/metrics:memory-use-recorder",
         "//src/test/java/com/google/devtools/build/lib/testutil",
         "//third_party:guava",
+        "//third_party:jsr305",
         "//third_party:junit4",
         "//third_party:mockito",
         "//third_party:truth",

src/test/java/com/google/devtools/build/lib/metrics/PostGCMemoryUseRecorderTest.java

@@ -35,6 +35,7 @@
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
+import javax.annotation.Nullable;
 import javax.management.Notification;
 import javax.management.NotificationEmitter;
 import javax.management.NotificationFilter;
@@ -99,7 +100,8 @@ public void noGcCauseEventsNotIgnored() {
             GarbageCollectionNotificationInfo.GARBAGE_COLLECTION_NOTIFICATION,
             "end of major GC",
             /*cause=*/ "No GC",
-            ImmutableMap.of("somepool", 100L));
+            ImmutableMap.of("somepool", 100L),
+            /*memUsedBefore=*/ null);
 
     underTest.handleNotification(notificationWithNoGcCause, /*handback=*/ null);
 
@@ -192,6 +194,34 @@ public void memoryUsageReportedZeroDoesntGetSet() {
     assertThat(rec.wasMemoryUsageReportedZero()).isFalse();
   }
 
+  @Test
+  public void totalGarbageReported() {
+    PostGCMemoryUseRecorder rec = new PostGCMemoryUseRecorder(new ArrayList<>());
+    assertThat(rec.getGarbageStats()).isEmpty();
+
+    rec.handleNotification(
+        createMockNotification(
+            GarbageCollectionNotificationInfo.GARBAGE_COLLECTION_NOTIFICATION,
+            "action",
+            "cause",
+            ImmutableMap.of("old", 1000L, "young", 2000L),
+            ImmutableMap.of("old", 5000L, "young", 10000L)),
+        /* handback= */ null);
+    assertThat(rec.getGarbageStats()).containsExactly("old", 4000L, "young", 8000L);
+    rec.handleNotification(
+        createMockNotification(
+            GarbageCollectionNotificationInfo.GARBAGE_COLLECTION_NOTIFICATION,
+            "action",
+            "cause",
+            ImmutableMap.of("young", 15000L),
+            ImmutableMap.of("young", 20000L)),
+        /* handback= */ null);
+    assertThat(rec.getGarbageStats()).containsExactly("old", 4000L, "young", 13000L);
+
+    rec.reset();
+    assertThat(rec.getGarbageStats()).isEmpty();
+  }
+
   private static GarbageCollectorMXBean createMXBeanWithName(String name) {
     GarbageCollectorMXBean b =
         mock(
@@ -215,19 +245,32 @@ private static MemoryUsage createMockMemoryUsage(long used) {
     return mu;
   }
 
+  private static ImmutableMap<String, MemoryUsage> createMemoryUsageMap(Map<String, Long> memUsed) {
+    ImmutableMap.Builder<String, MemoryUsage> memUsageMap = ImmutableMap.builder();
+    for (Map.Entry<String, Long> e : memUsed.entrySet()) {
+      memUsageMap.put(e.getKey(), createMockMemoryUsage(e.getValue()));
+    }
+    return memUsageMap.build();
+  }
+
   private Notification createMockNotification(
       String type, String action, Map<String, Long> memUsed) {
-    return createMockNotification(type, action, "dummycause", memUsed);
+    return createMockNotification(type, action, "dummycause", memUsed, /* memUsedBefore= */ null);
   }
 
   private Notification createMockNotification(
-      String type, String action, String cause, Map<String, Long> memUsed) {
-    ImmutableMap.Builder<String, MemoryUsage> memUsageMap = ImmutableMap.builder();
-    for (Map.Entry<String, Long> e : memUsed.entrySet()) {
-      memUsageMap.put(e.getKey(), createMockMemoryUsage(e.getValue()));
-    }
+      String type,
+      String action,
+      String cause,
+      Map<String, Long> memUsed,
+      @Nullable Map<String, Long> memUsedBefore) {
     GcInfo gcInfo = mock(GcInfo.class);
-    when(gcInfo.getMemoryUsageAfterGc()).thenReturn(memUsageMap.build());
+    ImmutableMap<String, MemoryUsage> memoryUsageMap = createMemoryUsageMap(memUsed);
+    when(gcInfo.getMemoryUsageAfterGc()).thenReturn(memoryUsageMap);
+    if (memUsedBefore != null) {
+      ImmutableMap<String, MemoryUsage> memoryUsageBeforeMap = createMemoryUsageMap(memUsedBefore);
+      when(gcInfo.getMemoryUsageBeforeGc()).thenReturn(memoryUsageBeforeMap);
+    }
 
     GarbageCollectionNotificationInfo notInfo =
         new GarbageCollectionNotificationInfo("DummyGCName", action, cause, gcInfo);