Report a few more GC stats in GC.stat

Author: Lillian Zhang

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

@@ -11,6 +11,8 @@
 
 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 org.truffleruby.SuppressFBWarnings;
@@ -23,6 +25,7 @@
 import org.truffleruby.builtins.Primitive;
 import org.truffleruby.builtins.PrimitiveArrayArgumentsNode;
 import org.truffleruby.collections.WeakValueCache;
+import org.truffleruby.core.array.RubyArray;
 import org.truffleruby.language.SafepointManager;
 import org.truffleruby.language.control.RaiseException;
 
@@ -103,10 +106,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 +121,100 @@ 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() {
             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];
+            for (MemoryPoolMXBean bean : ManagementFactory.getMemoryPoolMXBeans()) {
+                if (bean.getName().equals(memoryPoolNames[0])) {
+                    memoryPools[0] = beanToArray(bean);
+                } else if (bean.getName().equals(memoryPoolNames[1])) {
+                    memoryPools[1] = beanToArray(bean);
+                } else if (memoryPoolNames.length == 3 && bean.getName().equals(memoryPoolNames[2])) {
+                    memoryPools[2] = beanToArray(bean);
+                }
+            }
+
+            MemoryUsage usage = ManagementFactory.getMemoryMXBean().getHeapMemoryUsage();
+
+            // Use an object array instead because otherwise ArrayHelpers.java line 51 complains
+            Object[] memoryPoolNamesCast = new Object[memoryPoolNames.length];
+            for (int i = 0; i < memoryPoolNames.length; i++) {
+                memoryPoolNamesCast[i] = memoryPoolNames[i];
+            }
+
+
+            return createArray(
+                    new Object[]{
+                            time,
+                            count,
+                            minorCount,
+                            majorCount,
+                            unknownCount,
+                            usage.getCommitted(),
+                            usage.getUsed(),
+                            createArray(memoryPoolNamesCast),
+                            createArray(memoryPools) });
+        }
+
+        protected RubyArray usageToArray(MemoryUsage usage) {
+            return createArray(new Object[]{ usage.getCommitted(), usage.getInit(), usage.getMax(), usage.getUsed() });
+        }
+
+        protected RubyArray beanToArray(MemoryPoolMXBean bean) {
+            return createArray(
+                    new Object[]{
+                            usageToArray(bean.getUsage()),
+                            usageToArray(bean.getPeakUsage()),
+                            usageToArray(bean.getCollectionUsage()) });
         }
 
     }

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

@@ -76,10 +76,55 @@ def garbage_collect
   end
 
   def self.stat(option = nil)
+    time, count, minor_count, major_count, unknown_count, commited, used, memory_pool_names, memory_pool_info = Primitive.gc_stat()
+
+    # 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
+      :committed => 0.0,
+      :init => 0.0,
+      :max => 0.0,
+      :used => 0.0,
+      :peak_committed => 0.0,
+      :peak_init => 0.0,
+      :peak_max => 0.0,
+      :peak_used => 0.0,
+      :last_committed => 0.0,
+      :last_init => 0.0,
+      :last_max => 0.0,
+      :last_used => 0.0,
+      :heap_available_slots => commited, # should be the same as the calculated commited
+      :heap_live_slots => used, # should be the same as the calculated used
+      :heap_free_slots => commited - used,
     }
+
+    (0...memory_pool_names.length).each do |i|
+      # Populate memory pool specific stats
+      stat[Truffle::Interop.to_string(memory_pool_names[i])] = {
+        :committed => memory_pool_info[i][0][0],
+        :init => memory_pool_info[i][0][1],
+        :max => memory_pool_info[i][0][2],
+        :used => memory_pool_info[i][0][3],
+        :peak_committed => memory_pool_info[i][1][0],
+        :peak_init => memory_pool_info[i][1][1],
+        :peak_max => memory_pool_info[i][1][2],
+        :peak_used => memory_pool_info[i][1][3],
+        :last_committed => memory_pool_info[i][2][0],
+        :last_init => memory_pool_info[i][2][1],
+        :last_max => memory_pool_info[i][2][2],
+        :last_used => memory_pool_info[i][2][3],
+      }
+
+      # Calculate stats across memory pools
+      stat[Truffle::Interop.to_string(memory_pool_names[i])].each_pair do |key, value|
+        stat[key] += value
+      end
+    end
+
     return stat unless option
 
     if stat[option]