[GR-17457] Move GC heap stats to a separate GC.heap_stats method

PullRequest: truffleruby/2691

Author: eregon

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

@@ -138,26 +138,22 @@ protected long time() {
     @Primitive(name = "gc_stat")
     public abstract static class GCStatPrimitiveNode extends PrimitiveArrayArgumentsNode {
 
-        @TruffleBoundary
         @Specialization
-        protected RubyArray stat(
-                @Cached StringNodes.MakeStringNode makeStringNode) {
+        protected RubyArray stat() {
+            final long[] data = getGCData();
+            return createArray(data);
+        }
+
+        @TruffleBoundary
+        private long[] getGCData() {
             long time = 0;
-            int count = 0;
-            int minorCount = 0;
-            int majorCount = 0;
-            int unknownCount = 0;
-            String[] memoryPoolNames = new String[0];
-            Object[] memoryPools;
+            long count = 0;
+            long minorCount = 0;
+            long majorCount = 0;
+            long unknownCount = 0;
 
             // 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()) {
@@ -177,6 +173,43 @@ protected RubyArray stat(
                 }
             }
 
+            final MemoryUsage total = ManagementFactory.getMemoryMXBean().getHeapMemoryUsage();
+
+            return new long[]{
+                    time,
+                    count,
+                    minorCount,
+                    majorCount,
+                    unknownCount,
+                    total.getUsed(),
+                    total.getCommitted(),
+                    total.getInit(),
+                    total.getMax(),
+            };
+        }
+
+    }
+
+    @Primitive(name = "gc_heap_stats")
+    public abstract static class GCHeapStatsNode extends PrimitiveArrayArgumentsNode {
+
+        @TruffleBoundary
+        @Specialization
+        protected RubyArray heapStats(
+                @Cached StringNodes.MakeStringNode makeStringNode) {
+            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();
+                }
+            }
+
             // 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
@@ -190,33 +223,19 @@ protected RubyArray stat(
                 }
             }
 
-            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) });
+            return createArray(new Object[]{
+                    createArray(memoryPoolNamesCast),
+                    createArray(memoryPools) });
         }
 
-        protected RubyArray beanToArray(MemoryPoolMXBean bean) {
+        private RubyArray beanToArray(MemoryPoolMXBean bean) {
             MemoryUsage usage = bean.getUsage();
             MemoryUsage peak = bean.getPeakUsage();
             MemoryUsage last = bean.getCollectionUsage();

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

@@ -36,8 +36,8 @@
 
 module Truffle::GCOperations
   KNOWN_KEYS = %i[
-    count
     time
+    count
     minor_gc_count
     major_gc_count
     unknown_count
@@ -51,13 +51,12 @@ module Truffle::GCOperations
   ]
 
   def self.stat_hash(key = nil)
-    time, count, minor_count, major_count, unknown_count, heap, memory_pool_names, memory_pool_info = Primitive.gc_stat
-    used, committed, init, max = heap
+    time, count, minor_count, major_count, unknown_count, used, committed, init, max = Primitive.gc_stat
 
     # Initialize stat for statistics that come from memory pools, and populate it with some final stats (ordering similar to MRI)
     stat = {
-        count: count,
         time: time,
+        count: count,
         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
@@ -71,34 +70,6 @@ def self.stat_hash(key = nil)
     }
     stat.default = 0
 
-    unless Primitive.object_kind_of?(key, Symbol) # memory_pool_names are Strings
-      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 |k,v|
-            stat[k] += v if k.start_with?('peak_', 'last_')
-          end
-        end
-      end
-    end
-
     if key
       stat[key]
     else
@@ -160,6 +131,39 @@ def self.stat(key = nil)
     end
   end
 
+  def self.heap_stats
+    memory_pool_names, memory_pool_info = Primitive.gc_heap_stats
+
+    stat = GC.stat
+    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 |k,v|
+          stat[k] += v if k.start_with?('peak_', 'last_')
+        end
+      end
+    end
+
+    stat
+  end
+
   module Profiler
     @enabled = true
     @since   = 0