[GR-19220] Fix tracing of allocations from C and store allocation tracing information directly on RubyDynamicObject (#2403)

PullRequest: truffleruby/2804

Author: eregon

lib/truffle/objspace.rb

@@ -8,60 +8,52 @@
 # GNU General Public License version 2, or
 # GNU Lesser General Public License version 2.1.
 
-require 'json'
-require 'tempfile'
-require 'weakref'
+module Truffle::ObjSpace
+  def self.count_nodes_method(method, nodes)
+    node_stack = [Truffle.ast(method)]
+
+    until node_stack.empty?
+      node = node_stack.pop
+      next if node.nil?
+
+      name = node.first
+      children = node.drop(1)
+      nodes[name] ||= 0
+      nodes[name] += 1
+      node_stack.push(*children)
+    end
+  end
+end
 
 module ObjectSpace
+  module_function
 
   def count_nodes(nodes = {})
     ObjectSpace.each_object(Module) do |mod|
       mod.methods(false).each do |name|
-        count_nodes_method mod.method(name), nodes
+        Truffle::ObjSpace.count_nodes_method mod.method(name), nodes
       end
 
       mod.private_methods(false).each do |name|
-        count_nodes_method mod.method(name), nodes
+        Truffle::ObjSpace.count_nodes_method mod.method(name), nodes
       end
     end
 
     ObjectSpace.each_object(Proc) do |proc|
-      count_nodes_method proc, nodes
+      Truffle::ObjSpace.count_nodes_method proc, nodes
     end
 
     ObjectSpace.each_object(Method) do |method|
-      count_nodes_method method, nodes
+      Truffle::ObjSpace.count_nodes_method method, nodes
     end
 
     ObjectSpace.each_object(UnboundMethod) do |umethod|
-      count_nodes_method umethod, nodes
+      Truffle::ObjSpace.count_nodes_method umethod, nodes
     end
 
     nodes
   end
 
-  module_function :count_nodes
-
-  class << self
-
-    def count_nodes_method(method, nodes)
-      node_stack = [Truffle.ast(method)]
-
-      until node_stack.empty?
-        node = node_stack.pop
-        next if node.nil?
-
-        name = node.first
-        children = node.drop(1)
-        nodes[name] ||= 0
-        nodes[name] += 1
-        node_stack.push(*children)
-      end
-    end
-    private :count_nodes_method
-
-  end
-
   def count_objects_size(hash = {})
     total = 0
     ObjectSpace.each_object(Class) do |klass|
@@ -72,7 +64,6 @@ def count_objects_size(hash = {})
     hash[:TOTAL] = total
     hash
   end
-  module_function :count_objects_size
 
   def count_tdata_objects(hash = {})
     ObjectSpace.each_object do |object|
@@ -82,11 +73,11 @@ def count_tdata_objects(hash = {})
     end
     hash
   end
-  module_function :count_tdata_objects
 
   def dump(object, output: :string)
     case output
     when :string
+      require 'json'
       json = {
         address: '0x' + object.object_id.to_s(16),
         class: '0x' + object.class.object_id.to_s(16),
@@ -119,6 +110,7 @@ def dump(object, output: :string)
       end
       JSON.generate(json)
     when :file
+      require 'tempfile'
       f = Tempfile.new(['rubyobj', '.json'])
       f.write dump(object, output: :string)
       f.close
@@ -128,7 +120,6 @@ def dump(object, output: :string)
       nil
     end
   end
-  module_function :dump
 
   def dump_all(output: :file)
     case output
@@ -139,6 +130,7 @@ def dump_all(output: :file)
       end
       objects.join("\n")
     when :file
+      require 'tempfile'
       f = Tempfile.new(['ruby', '.json'])
       f.write dump_all(output: :string)
       f.close
@@ -151,7 +143,6 @@ def dump_all(output: :file)
       nil
     end
   end
-  module_function :dump_all
 
   def memsize_of(object)
     size = Truffle::ObjSpace.memsize_of(object)
@@ -163,7 +154,6 @@ def memsize_of(object)
       size
     end
   end
-  module_function :memsize_of
 
   def memsize_of_all(klass = BasicObject)
     total = 0
@@ -172,17 +162,14 @@ def memsize_of_all(klass = BasicObject)
     end
     total
   end
-  module_function :memsize_of_all
 
   def reachable_objects_from(object)
     Truffle::ObjSpace.adjacent_objects(object)
   end
-  module_function :reachable_objects_from
 
   def reachable_objects_from_root
-    {'roots' => Truffle::ObjSpace.root_objects}
+    { 'roots' => Truffle::ObjSpace.root_objects }
   end
-  module_function :reachable_objects_from_root
 
   def trace_object_allocations
     trace_object_allocations_start
@@ -192,89 +179,40 @@ def trace_object_allocations
       trace_object_allocations_stop
     end
   end
-  module_function :trace_object_allocations
-
-  def trace_object_allocations_clear
-    TruffleRuby.synchronized(ALLOCATIONS) do
-      ALLOCATIONS.clear
-    end
-  end
-  module_function :trace_object_allocations_clear
 
   def trace_object_allocations_debug_start
     trace_object_allocations_start
   end
-  module_function :trace_object_allocations_debug_start
 
   def trace_object_allocations_start
     Truffle::ObjSpace.trace_allocations_start
   end
-  module_function :trace_object_allocations_start
 
   def trace_object_allocations_stop
     Truffle::ObjSpace.trace_allocations_stop
   end
-  module_function :trace_object_allocations_stop
+
+  def trace_object_allocations_clear
+    Truffle::ObjSpace.trace_allocations_clear
+  end
 
   def allocation_class_path(object)
-    allocation = TruffleRuby.synchronized(ALLOCATIONS) do
-      ALLOCATIONS[object]
-    end
-    return nil if allocation.nil?
-    allocation.class_path
+    Primitive.allocation_class_path(object)
   end
-  module_function :allocation_class_path
 
   def allocation_generation(object)
-    allocation = TruffleRuby.synchronized(ALLOCATIONS) do
-      ALLOCATIONS[object]
-    end
-    return nil if allocation.nil?
-    allocation.generation
+    Primitive.allocation_generation(object)
   end
-  module_function :allocation_generation
 
   def allocation_method_id(object)
-    allocation = TruffleRuby.synchronized(ALLOCATIONS) do
-      ALLOCATIONS[object]
-    end
-    return nil if allocation.nil?
-
-    method_id = allocation.method_id
-    # The allocator function is hidden in MRI
-    method_id = :new if method_id == :__allocate__
-    method_id
+    Primitive.allocation_method_id(object)
   end
-  module_function :allocation_method_id
 
   def allocation_sourcefile(object)
-    allocation = TruffleRuby.synchronized(ALLOCATIONS) do
-      ALLOCATIONS[object]
-    end
-    return nil if allocation.nil?
-    allocation.sourcefile
+    Primitive.allocation_sourcefile(object)
   end
-  module_function :allocation_sourcefile
 
   def allocation_sourceline(object)
-    allocation = TruffleRuby.synchronized(ALLOCATIONS) do
-      ALLOCATIONS[object]
-    end
-    return nil if allocation.nil?
-    allocation.sourceline
-  end
-  module_function :allocation_sourceline
-
-  Allocation = Struct.new(:class_path, :method_id, :sourcefile, :sourceline, :generation)
-
-  ALLOCATIONS = {}.compare_by_identity
-
-  def trace_allocation(object, class_path, method_id, sourcefile, sourceline, generation)
-    allocation = Allocation.new(class_path, method_id, sourcefile, sourceline, generation)
-    TruffleRuby.synchronized(ALLOCATIONS) do
-      ALLOCATIONS[object] = allocation
-    end
+    Primitive.allocation_sourceline(object)
   end
-  module_function :trace_allocation
-
 end

spec/ruby/library/objectspace/memsize_of_all_spec.rb

@@ -0,0 +1,21 @@
+require_relative '../../spec_helper'
+require 'objspace'
+
+describe "ObjectSpace.memsize_of_all" do
+  it "returns a non-zero Integer for all objects" do
+    ObjectSpace.memsize_of_all.should be_kind_of(Integer)
+    ObjectSpace.memsize_of_all.should > 0
+  end
+
+  it "returns a non-zero Integer for Class" do
+    ObjectSpace.memsize_of_all(Class).should be_kind_of(Integer)
+    ObjectSpace.memsize_of_all(Class).should > 0
+  end
+
+  it "increases when a new object is allocated" do
+    before = ObjectSpace.memsize_of_all(Class)
+    o = Class.new
+    after = ObjectSpace.memsize_of_all(Class)
+    after.should > before
+  end
+end

spec/ruby/library/objectspace/memsize_of_spec.rb

@@ -16,7 +16,7 @@
     ObjectSpace.memsize_of(:abc).should == 0
   end
 
-  it "returns an Integer for an Object" do
+  it "returns a positive Integer for an Object" do
     obj = Object.new
     ObjectSpace.memsize_of(obj).should be_kind_of(Integer)
     ObjectSpace.memsize_of(obj).should > 0