[GR-19220] Report a few more GC stats in GC.stat (#2280)

PullRequest: truffleruby/2467

Author: eregon

spec/ruby/core/gc/stat_spec.rb

@@ -13,4 +13,16 @@
     stat.should be_kind_of(Hash)
     stat.keys.should include(:count)
   end
+
+  it "increases count after GC is run" do
+    count = GC.stat(:count)
+    GC.start
+    GC.stat(:count).should > count
+  end
+
+  it "increases major_gc_count after GC is run" do
+    count = GC.stat(:major_gc_count)
+    GC.start
+    GC.stat(:major_gc_count).should > count
+  end
 end

spec/tags/core/gc/stat_tags.txt

@@ -0,0 +1,2 @@
+slow:GC.stat increases count after GC is run
+slow:GC.stat increases major_gc_count after GC is run

src/main/java/org/truffleruby/core/GCNodes.java

@@ -11,8 +11,13 @@
 
 import java.lang.management.GarbageCollectorMXBean;
 import java.lang.management.ManagementFactory;
+import java.lang.management.MemoryPoolMXBean;
+import java.lang.management.MemoryUsage;
 import java.time.Duration;
+import java.util.Arrays;
 
+import com.oracle.truffle.api.dsl.Cached;
+import org.jcodings.specific.UTF8Encoding;
 import org.truffleruby.SuppressFBWarnings;
 import org.truffleruby.builtins.CoreMethod;
 import org.truffleruby.builtins.CoreMethodArrayArgumentsNode;
@@ -23,6 +28,9 @@
 import org.truffleruby.builtins.Primitive;
 import org.truffleruby.builtins.PrimitiveArrayArgumentsNode;
 import org.truffleruby.collections.WeakValueCache;
+import org.truffleruby.core.array.RubyArray;
+import org.truffleruby.core.rope.CodeRange;
+import org.truffleruby.core.string.StringNodes;
 import org.truffleruby.language.SafepointManager;
 import org.truffleruby.language.control.RaiseException;
 
@@ -103,10 +111,6 @@ public abstract static class CountNode extends CoreMethodArrayArgumentsNode {
         @TruffleBoundary
         @Specialization
         protected int count() {
-            return getCollectionCount();
-        }
-
-        public static int getCollectionCount() {
             int count = 0;
             for (GarbageCollectorMXBean bean : ManagementFactory.getGarbageCollectorMXBeans()) {
                 count += bean.getCollectionCount();
@@ -122,15 +126,115 @@ public abstract static class TimeNode extends CoreMethodArrayArgumentsNode {
         @TruffleBoundary
         @Specialization
         protected long time() {
-            return getCollectionTime();
+            long time = 0;
+            for (GarbageCollectorMXBean bean : ManagementFactory.getGarbageCollectorMXBeans()) {
+                time += bean.getCollectionTime();
+            }
+            return time;
         }
 
-        public static long getCollectionTime() {
+    }
+
+    @Primitive(name = "gc_stat")
+    public static abstract class GCStatPrimitiveNode extends PrimitiveArrayArgumentsNode {
+
+        @TruffleBoundary
+        @Specialization
+        protected RubyArray stat(
+                @Cached StringNodes.MakeStringNode makeStringNode) {
             long time = 0;
+            int count = 0;
+            int minorCount = 0;
+            int majorCount = 0;
+            int unknownCount = 0;
+            String[] memoryPoolNames = new String[0];
+            Object[] memoryPools;
+
+            // Get GC time and counts from GarbageCollectorMXBean
             for (GarbageCollectorMXBean bean : ManagementFactory.getGarbageCollectorMXBeans()) {
+                // Get MemoryPoolName relevant to GC
+                if (bean.getMemoryPoolNames().length > memoryPoolNames.length) {
+                    // Since old generation memory pools are a superset of young generation memory pools,
+                    // it suffices to check that we have the longer list of memory pools
+                    memoryPoolNames = bean.getMemoryPoolNames();
+                }
                 time += bean.getCollectionTime();
+                count += bean.getCollectionCount();
+                switch (bean.getName()) {
+                    case "G1 Young Generation": // during 'jvm' and 'jvm-ce'
+                    case "PS Scavenge": // during 'jvm --vm.XX:+UseParallelGC'
+                    case "young generation scavenger": // during 'native'
+                        minorCount += bean.getCollectionCount();
+                        break;
+                    case "G1 Old Generation": // during 'jvm' and 'jvm-ce'
+                    case "PS MarkSweep": // during 'jvm --vm.XX:+UseParallelGC'
+                    case "complete scavenger": // during 'native'
+                        majorCount += bean.getCollectionCount();
+                        break;
+                    default:
+                        unknownCount += bean.getCollectionCount();
+                        break;
+                }
             }
-            return time;
+
+            // Get memory usage values from relevant memory pools (2-3 / ~8 are relevant)
+            memoryPools = new Object[memoryPoolNames.length];
+            // On Native Image, ManagementFactory.getMemoryPoolMXBeans() is empty
+            Arrays.fill(memoryPools, nil);
+            for (int i = 0; i < memoryPoolNames.length; i++) {
+                String memoryPoolName = memoryPoolNames[i];
+                for (MemoryPoolMXBean bean : ManagementFactory.getMemoryPoolMXBeans()) {
+                    if (bean.getName().equals(memoryPoolName)) {
+                        memoryPools[i] = beanToArray(bean);
+                    }
+                }
+            }
+
+            MemoryUsage total = ManagementFactory.getMemoryMXBean().getHeapMemoryUsage();
+
+            Object[] memoryPoolNamesCast = new Object[memoryPoolNames.length];
+            for (int i = 0; i < memoryPoolNames.length; i++) {
+                memoryPoolNamesCast[i] = makeStringNode
+                        .executeMake(memoryPoolNames[i], UTF8Encoding.INSTANCE, CodeRange.CR_UNKNOWN);
+            }
+
+
+            return createArray(
+                    new Object[]{
+                            time,
+                            count,
+                            minorCount,
+                            majorCount,
+                            unknownCount,
+                            createArray(new long[]{
+                                    total.getUsed(),
+                                    total.getCommitted(),
+                                    total.getInit(),
+                                    total.getMax(),
+                            }),
+                            createArray(memoryPoolNamesCast),
+                            createArray(memoryPools) });
+        }
+
+        protected RubyArray beanToArray(MemoryPoolMXBean bean) {
+            MemoryUsage usage = bean.getUsage();
+            MemoryUsage peak = bean.getPeakUsage();
+            MemoryUsage last = bean.getCollectionUsage();
+            return createArray(
+                    new long[]{
+                            usage.getUsed(),
+                            usage.getCommitted(),
+                            usage.getInit(),
+                            usage.getMax(),
+                            peak.getUsed(),
+                            peak.getCommitted(),
+                            peak.getInit(),
+                            peak.getMax(),
+                            last.getUsed(),
+                            last.getCommitted(),
+                            last.getInit(),
+                            last.getMax(),
+                    });
         }
 
     }

src/main/ruby/truffleruby/core/gc.rb

@@ -76,10 +76,59 @@ def garbage_collect
   end
 
   def self.stat(option = nil)
+    time, count, minor_count, major_count, unknown_count, heap, memory_pool_names, memory_pool_info = Primitive.gc_stat()
+    used, committed, init, max = heap
+
+    # Initialize stat for statistics that come from memory pools, and populate it with some final stats
     stat = {
-      count: GC.count,
-      time: GC.time,
+      count: count,
+      time: time,
+      minor_gc_count: minor_count,
+      major_gc_count: major_count,
+      unknown_count: unknown_count, # if nonzero, major or minor count needs to be updated for this GC case
+      heap_available_slots: committed,
+      heap_live_slots: used,
+      heap_free_slots: committed - used,
+      used: used,
+      committed: committed,
+      init: init,
+      max: max,
+      peak_used: 0,
+      peak_committed: 0,
+      peak_init: 0,
+      peak_max: 0,
+      last_used: 0,
+      last_committed: 0,
+      last_init: 0,
+      last_max: 0,
     }
+
+    memory_pool_names.each_with_index do |memory_pool_name, i|
+      # Populate memory pool specific stats
+      info = memory_pool_info[i]
+      if info
+        stat[memory_pool_name] = data = {
+          used: info[0],
+          committed: info[1],
+          init: info[2],
+          max: info[3],
+          peak_used: info[4],
+          peak_committed: info[5],
+          peak_init: info[6],
+          peak_max: info[7],
+          last_used: info[8],
+          last_committed: info[9],
+          last_init: info[10],
+          last_max: info[11],
+        }
+
+        # Calculate stats across memory pools for peak_/last_ (we already know the values for current usage)
+        data.each_pair do |key, value|
+          stat[key] += value if key.start_with?('peak_', 'last_')
+        end
+      end
+    end
+
     return stat unless option
 
     if stat[option]