ruby-prof 1.6.3 → 1.7.1

data/ext/ruby_prof/rp_method.c

@@ -4,6 +4,17 @@
 #include "rp_allocation.h"
 #include "rp_call_trees.h"
 #include "rp_method.h"
+#include "rp_profile.h"
+
+#include <ruby/version.h>
+
+// Needed for Ruby 3.0.* and 3.1.*
+#if RUBY_API_VERSION_MAJOR == 3 && RUBY_API_VERSION_MINOR < 2
+   VALUE rb_class_attached_object(VALUE klass)
+   {
+     return rb_iv_get(klass, "__attached__");
+   }
+#endif
 
 VALUE cRpMethodInfo;
 
@@ -20,7 +31,7 @@ VALUE resolve_klass(VALUE klass, unsigned int* klass_flags)
     {
         /* We have come across a singleton object. First
            figure out what it is attached to.*/
-        VALUE attached = rb_iv_get(klass, "__attached__");
+        VALUE attached = rb_class_attached_object(klass);
 
         switch (BUILTIN_TYPE(attached))
         {
@@ -90,19 +101,8 @@ VALUE resolve_klass_name(VALUE klass, unsigned int* klass_flags)
 
 st_data_t method_key(VALUE klass, VALUE msym)
 {
-    VALUE resolved_klass = klass;
-
-    /* Is this an include for a module?  If so get the actual
-        module class since we want to combine all profiling
-        results for that module. */
-    if (klass == 0 || klass == Qnil)
-    {
-        resolved_klass = Qnil;
-    }
-    else if (BUILTIN_TYPE(klass) == T_ICLASS)
-    {
-        resolved_klass = RBASIC_CLASS(klass);
-    }
+    unsigned int klass_flags = 0;
+    VALUE resolved_klass = resolve_klass(klass, &klass_flags);
 
     st_data_t hash = rb_hash_start(0);
     hash = rb_hash_uint(hash, resolved_klass);
@@ -125,7 +125,7 @@ prof_method_t* prof_get_method(VALUE self)
     return result;
 }
 
-prof_method_t* prof_method_create(VALUE profile, VALUE klass, VALUE msym, VALUE source_file, int source_line)
+prof_method_t* prof_method_create(struct prof_profile_t* profile, VALUE klass, VALUE msym, VALUE source_file, int source_line)
 {
     prof_method_t* result = ALLOC(prof_method_t);
     result->profile = profile;
@@ -204,14 +204,16 @@ void prof_method_mark(void* data)
 
     prof_method_t* method = (prof_method_t*)data;
 
-    if (method->profile != Qnil)
-        rb_gc_mark_movable(method->profile);
-
     if (method->object != Qnil)
-        rb_gc_mark_movable(method->object);
+      rb_gc_mark_movable(method->object);
+
+    // Mark the profile to keep it alive. Can't call prof_profile_mark because that would
+    // cause recursion
+    if (method->profile && method->profile->object != Qnil)
+        rb_gc_mark(method->profile->object);
 
-    rb_gc_mark_movable(method->klass_name);
-    rb_gc_mark_movable(method->method_name);
+    rb_gc_mark(method->klass_name);
+    rb_gc_mark(method->method_name);
     rb_gc_mark(method->source_file);
 
     if (method->klass != Qnil)
@@ -225,14 +227,13 @@ void prof_method_compact(void* data)
 {
     prof_method_t* method = (prof_method_t*)data;
     method->object = rb_gc_location(method->object);
-    method->profile = rb_gc_location(method->profile);
     method->klass_name = rb_gc_location(method->klass_name);
     method->method_name = rb_gc_location(method->method_name);
 }
 
 static VALUE prof_method_allocate(VALUE klass)
 {
-    prof_method_t* method_data = prof_method_create(Qnil, Qnil, Qnil, Qnil, 0);
+    prof_method_t* method_data = prof_method_create(NULL, Qnil, Qnil, Qnil, 0);
     method_data->object = prof_method_wrap(method_data);
     return method_data->object;
 }
@@ -260,7 +261,7 @@ VALUE prof_method_wrap(prof_method_t* method)
     return method->object;
 }
 
-st_table* method_table_create()
+st_table* method_table_create(void)
 {
     return rb_st_init_numtable();
 }
@@ -516,7 +517,7 @@ static VALUE prof_method_load(VALUE self, VALUE data)
     return data;
 }
 
-void rp_init_method_info()
+void rp_init_method_info(void)
 {
     /* MethodInfo */
     cRpMethodInfo = rb_define_class_under(mProf, "MethodInfo", rb_cObject);

data/ext/ruby_prof/rp_method.h

@@ -18,11 +18,14 @@ enum {
     kOtherSingleton = 0x10                    // Singleton of unknown object
 };
 
+// Don't want to include ruby_prof.h to avoid a circular reference
+struct prof_profile_t;
+
 // Profiling information for each method.
 // Excluded methods have no call_trees, source_klass, or source_file.
 typedef struct prof_method_t
 {
-    VALUE profile;                          // Profile this method is associated with - needed for mark phase
+    struct prof_profile_t* profile;                  // Profile this method is associated with - needed for mark phase
     struct prof_call_trees_t* call_trees;   // Call infos that call this method
     st_table* allocations_table;            // Tracks object allocations
 
@@ -51,7 +54,7 @@ prof_method_t* method_table_lookup(st_table* table, st_data_t key);
 size_t method_table_insert(st_table* table, st_data_t key, prof_method_t* val);
 void method_table_free(st_table* table);
 void prof_method_table_merge(st_table* self, st_table* other);
-prof_method_t* prof_method_create(VALUE profile, VALUE klass, VALUE msym, VALUE source_file, int source_line);
+prof_method_t* prof_method_create(struct prof_profile_t* profile, VALUE klass, VALUE msym, VALUE source_file, int source_line);
 prof_method_t* prof_get_method(VALUE self);
 
 VALUE prof_method_wrap(prof_method_t* result);

data/ext/ruby_prof/rp_profile.c

@@ -105,7 +105,7 @@ static int excludes_method(st_data_t key, prof_profile_t* profile)
 
 static prof_method_t* create_method(prof_profile_t* profile, st_data_t key, VALUE klass, VALUE msym, VALUE source_file, int source_line)
 {
-    prof_method_t* result = prof_method_create(profile->object, klass, msym, source_file, source_line);
+    prof_method_t* result = prof_method_create(profile, klass, msym, source_file, source_line);
     method_table_insert(profile->last_thread_data->method_table, result->key, result);
 
     return result;
@@ -863,7 +863,7 @@ static VALUE prof_exclude_method(VALUE self, VALUE klass, VALUE msym)
 
     if (!method)
     {
-        method = prof_method_create(self, klass, msym, Qnil, 0);
+        method = prof_method_create(profile, klass, msym, Qnil, 0);
         method_table_insert(profile->exclude_methods_tbl, method->key, method);
     }
 

data/ext/ruby_prof/rp_profile.h

@@ -1,36 +1,36 @@
-/* Copyright (C) 2005-2019 Shugo Maeda <shugo@ruby-lang.org> and Charlie Savage <cfis@savagexi.com>
-   Please see the LICENSE file for copyright and distribution information */
-
-#ifndef __RP_PROFILE_H__
-#define __RP_PROFILE_H__
-
-#include "ruby_prof.h"
-#include "rp_measurement.h"
-#include "rp_thread.h"
-
-extern VALUE cProfile;
-
-typedef struct prof_profile_t
-{
-    VALUE object;
-    VALUE running;
-    VALUE paused;
-
-    prof_measurer_t* measurer;
-
-    VALUE tracepoints;
-
-    st_table* threads_tbl;
-    st_table* exclude_threads_tbl;
-    st_table* include_threads_tbl;
-    st_table* exclude_methods_tbl;
-    thread_data_t* last_thread_data;
-    double measurement_at_pause_resume;
-    bool allow_exceptions;
-} prof_profile_t;
-
-void rp_init_profile(void);
-prof_profile_t* prof_get_profile(VALUE self);
-
-
-#endif //__RP_PROFILE_H__
+/* Copyright (C) 2005-2019 Shugo Maeda <shugo@ruby-lang.org> and Charlie Savage <cfis@savagexi.com>
+   Please see the LICENSE file for copyright and distribution information */
+
+#ifndef __RP_PROFILE_H__
+#define __RP_PROFILE_H__
+
+#include "ruby_prof.h"
+#include "rp_measurement.h"
+#include "rp_thread.h"
+
+extern VALUE cProfile;
+
+typedef struct prof_profile_t
+{
+    VALUE object;
+    VALUE running;
+    VALUE paused;
+
+    prof_measurer_t* measurer;
+
+    VALUE tracepoints;
+
+    st_table* threads_tbl;
+    st_table* exclude_threads_tbl;
+    st_table* include_threads_tbl;
+    st_table* exclude_methods_tbl;
+    thread_data_t* last_thread_data;
+    double measurement_at_pause_resume;
+    bool allow_exceptions;
+} prof_profile_t;
+
+void rp_init_profile(void);
+prof_profile_t* prof_get_profile(VALUE self);
+
+
+#endif //__RP_PROFILE_H__

data/ext/ruby_prof/rp_stack.c

@@ -6,7 +6,7 @@
 #define INITIAL_STACK_SIZE 16
 
 // Creates a stack of prof_frame_t to keep track of timings for active methods.
-prof_stack_t* prof_stack_create()
+prof_stack_t* prof_stack_create(void)
 {
     prof_stack_t* stack = ALLOC(prof_stack_t);
     stack->start = ZALLOC_N(prof_frame_t, INITIAL_STACK_SIZE);

data/ext/ruby_prof/rp_thread.c

@@ -172,7 +172,7 @@ thread_data_t* prof_get_thread(VALUE self)
 // ======   Thread Table  ======
 // The thread table is hash keyed on ruby fiber_id that stores instances of thread_data_t.
 
-st_table* threads_table_create()
+st_table* threads_table_create(void)
 {
     return rb_st_init_numtable();
 }

data/ext/ruby_prof/ruby_prof.c

@@ -36,7 +36,7 @@
 
 VALUE mProf;
 
-void Init_ruby_prof()
+void Init_ruby_prof(void)
 {
     mProf = rb_define_module("RubyProf");
 

data/ext/ruby_prof/ruby_prof.h

@@ -1,34 +1,34 @@
-/* Copyright (C) 2005-2019 Shugo Maeda <shugo@ruby-lang.org> and Charlie Savage <cfis@savagexi.com>
-   Please see the LICENSE file for copyright and distribution information */
-
-#ifndef __RUBY_PROF_H__
-#define __RUBY_PROF_H__
-
-#include <ruby.h>
-#include <ruby/debug.h>
-#include <stdio.h>
-#include <stdbool.h>
-
-#ifndef rb_st_lookup
-#define rb_st_foreach st_foreach
-#define rb_st_free_table st_free_table
-#define rb_st_init_numtable st_init_numtable
-#define rb_st_insert st_insert
-#define rb_st_lookup st_lookup
-#endif
-
-
-extern VALUE mProf;
-
-// This method is not exposed in Ruby header files - at least not as of Ruby 2.6.3 :(
-extern size_t rb_obj_memsize_of(VALUE);
-
-typedef enum
-{
-  OWNER_UNKNOWN = 0,
-  OWNER_RUBY = 1,
-  OWNER_C = 2
-} prof_owner_t;
-
-
-#endif //__RUBY_PROF_H__
+/* Copyright (C) 2005-2019 Shugo Maeda <shugo@ruby-lang.org> and Charlie Savage <cfis@savagexi.com>
+   Please see the LICENSE file for copyright and distribution information */
+
+#ifndef __RUBY_PROF_H__
+#define __RUBY_PROF_H__
+
+#include <ruby.h>
+#include <ruby/debug.h>
+#include <stdio.h>
+#include <stdbool.h>
+
+#ifndef rb_st_lookup
+#define rb_st_foreach st_foreach
+#define rb_st_free_table st_free_table
+#define rb_st_init_numtable st_init_numtable
+#define rb_st_insert st_insert
+#define rb_st_lookup st_lookup
+#endif
+
+
+extern VALUE mProf;
+
+// This method is not exposed in Ruby header files - at least not as of Ruby 2.6.3 :(
+extern size_t rb_obj_memsize_of(VALUE);
+
+typedef enum
+{
+  OWNER_UNKNOWN = 0,
+  OWNER_RUBY = 1,
+  OWNER_C = 2
+} prof_owner_t;
+
+
+#endif //__RUBY_PROF_H__

data/ext/ruby_prof/vc/ruby_prof.vcxproj

@@ -66,7 +66,7 @@
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
     <TargetExt>.so</TargetExt>
-    <OutDir>$(SolutionDir)\..</OutDir>
+    <OutDir>$(SolutionDir)\..\</OutDir>
   </PropertyGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
     <ClCompile>
@@ -104,20 +104,18 @@
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
     <ClCompile>
-      <AdditionalIncludeDirectories>C:\msys64\usr\local\ruby-3.2.1-vc\include\ruby-3.2.0\x64-mswin64_140;C:\msys64\usr\local\ruby-3.2.1-vc\include\ruby-3.2.0;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalIncludeDirectories>C:\msys64\usr\local\ruby-3.3.0-vc\include\ruby-3.3.0\x64-mswin64_140;C:\msys64\usr\local\ruby-3.3.0-vc\include\ruby-3.3.0;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <Optimization>Disabled</Optimization>
       <PreprocessorDefinitions>%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <WarningLevel>Level3</WarningLevel>
     </ClCompile>
     <Link>
-      <AdditionalLibraryDirectories>C:\msys64\usr\local\ruby-3.2.1-vc\lib;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
-      <AdditionalDependencies>x64-vcruntime140-ruby320.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalLibraryDirectories>C:\msys64\usr\local\ruby-3.3.0-vc\lib;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
+      <AdditionalDependencies>x64-vcruntime140-ruby330.lib;%(AdditionalDependencies)</AdditionalDependencies>
       <ModuleDefinitionFile>ruby_prof.def</ModuleDefinitionFile>
       <SubSystem>Console</SubSystem>
     </Link>
-    <ProjectReference>
-      <LinkLibraryDependencies>false</LinkLibraryDependencies>
-    </ProjectReference>
+    <ProjectReference />
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
     <ClCompile>

data/lib/ruby-prof/compatibility.rb

@@ -99,15 +99,15 @@ module RubyProf
 
   class << self
     extend Gem::Deprecate
-    deprecate :measure_mode, "Profile#measure_mode", 2023, 6
-    deprecate :measure_mode=, "Profile#measure_mode=", 2023, 6
-    deprecate :exclude_threads, "Profile#exclude_threads", 2023, 6
-    deprecate :exclude_threads=, "Profile#initialize", 2023, 6
-    deprecate :start, "Profile#start", 2023, 6
-    deprecate :pause, "Profile#pause", 2023, 6
-    deprecate :stop, "Profile#stop", 2023, 6
-    deprecate :resume, "Profile#resume", 2023, 6
-    deprecate :running?, "Profile#running?", 2023, 6
-    deprecate :profile, "Profile.profile", 2023, 6
+    deprecate :measure_mode, "RubyProf::Profile#measure_mode", 2023, 6
+    deprecate :measure_mode=, "RubyProf::Profile#measure_mode=", 2023, 6
+    deprecate :exclude_threads, "RubyProf::Profile#exclude_threads", 2023, 6
+    deprecate :exclude_threads=, "RubyProf::Profile#initialize", 2023, 6
+    deprecate :start, "RubyProf::Profile#start", 2023, 6
+    deprecate :pause, "RubyProf::Profile#pause", 2023, 6
+    deprecate :stop, "RubyProf::Profile#stop", 2023, 6
+    deprecate :resume, "RubyProf::Profile#resume", 2023, 6
+    deprecate :running?, "RubyProf::Profile#running?", 2023, 6
+    deprecate :profile, "RubyProf::Profile.profile", 2023, 6
   end
 end

data/lib/ruby-prof/exclude_common_methods.rb

@@ -22,18 +22,24 @@ module RubyProf
       #  Fundamental Types
       ##
 
-      exclude_methods(profile, BasicObject,  :"!=")
-      exclude_methods(profile, Method,       :"[]")
+      exclude_methods(profile, BasicObject,  :!=)
+      exclude_methods(profile, Kernel,       :"block_given?")
+      exclude_methods(profile, Method,       :[])
       exclude_methods(profile, Module,       :new)
       exclude_methods(profile, Class,        :new)
       exclude_methods(profile, Proc,         :call, :yield)
       exclude_methods(profile, Range,        :each)
-      exclude_methods(profile, Integer,      :times)
 
       ##
       #  Value Types
       ##
 
+      exclude_methods(profile, Integer, [
+        :times,
+        :succ,
+        :<
+      ])
+
       exclude_methods(profile, String, [
         :sub,
         :sub!,

data/lib/ruby-prof/method_info.rb

@@ -1,85 +1,87 @@
-# encoding: utf-8
-
-module RubyProf
-  # The MethodInfo class is used to track information about each method that is profiled.
-  # You cannot create a MethodInfo object directly, they are generated while running a profile.
-  class MethodInfo
-    include Comparable
-
-    # Returns the full name of a class. The interpretation of method names is:
-    #
-    # * MyObject#test - An method defined in a class
-    # * <Class:MyObject>#test - A method defined in a singleton class.
-    # * <Module:MyObject>#test - A method defined in a singleton module.
-    # * <Object:MyObject>#test - A method defined in a singleton object.
-    def full_name
-      decorated_class_name = case self.klass_flags
-                             when 0x2
-                               "<Class::#{klass_name}>"
-                             when 0x4
-                               "<Module::#{klass_name}>"
-                             when 0x8
-                               "<Object::#{klass_name}>"
-                             else
-                               klass_name
-                             end
-
-      "#{decorated_class_name}##{method_name}"
-    end
-
-    # The number of times this method was called
-    def called
-      self.measurement.called
-    end
-
-    # The total time this method took - includes self time + wait time + child time
-    def total_time
-      self.measurement.total_time
-    end
-
-    # The time this method took to execute
-    def self_time
-      self.measurement.self_time
-    end
-
-    # The time this method waited for other fibers/threads to execute
-    def wait_time
-      self.measurement.wait_time
-    end
-
-    # The time this method's children took to execute
-    def children_time
-      self.total_time - self.self_time - self.wait_time
-    end
-
-    def eql?(other)
-      self.hash == other.hash
-    end
-
-    def ==(other)
-      self.eql?(other)
-    end
-
-    def <=>(other)
-      if other.nil?
-        -1
-      elsif self.full_name == other.full_name
-        0
-      elsif self.total_time < other.total_time
-        -1
-      elsif self.total_time > other.total_time
-        1
-      elsif self.call_trees.min_depth < other.call_trees.min_depth
-        1
-      elsif self.call_trees.min_depth > other.call_trees.min_depth
-        -1
-      else
-        self.full_name <=> other.full_name
-      end
-    end
-
-    def to_s
-      "#{self.full_name} (c: #{self.called}, tt: #{self.total_time}, st: #{self.self_time}, wt: #{wait_time}, ct: #{self.children_time})"
-    end
-  end
-end
+# encoding: utf-8
+
+module RubyProf
+  # The MethodInfo class is used to track information about each method that is profiled.
+  # You cannot create a MethodInfo object directly, they are generated while running a profile.
+  class MethodInfo
+    include Comparable
+
+    # Returns the full name of a class. The interpretation of method names is:
+    #
+    # * MyObject#test - An method defined in a class
+    # * <Class:MyObject>#test - A method defined in a singleton class.
+    # * <Module:MyObject>#test - A method defined in a singleton module.
+    # * <Object:MyObject>#test - A method defined in a singleton object.
+    def full_name
+      decorated_class_name = case self.klass_flags
+                             when 0x2
+                               "<Class::#{klass_name}>"
+                             when 0x4
+                               "<Module::#{klass_name}>"
+                             when 0x8
+                               "<Object::#{klass_name}>"
+                             else
+                               klass_name
+                             end
+
+      "#{decorated_class_name}##{method_name}"
+    end
+
+    # The number of times this method was called
+    def called
+      self.measurement.called
+    end
+
+    # The total time this method took - includes self time + wait time + child time
+    def total_time
+      self.measurement.total_time
+    end
+
+    # The time this method took to execute
+    def self_time
+      self.measurement.self_time
+    end
+
+    # The time this method waited for other fibers/threads to execute
+    def wait_time
+      self.measurement.wait_time
+    end
+
+    # The time this method's children took to execute
+    def children_time
+      self.total_time - self.self_time - self.wait_time
+    end
+
+    def eql?(other)
+      self.hash == other.hash
+    end
+
+    def ==(other)
+      self.eql?(other)
+    end
+
+    def <=>(other)
+      sort_delta = 0.0001
+
+      if other.nil?
+        -1
+      elsif self.full_name == other.full_name
+        0
+      elsif self.total_time < other.total_time && (self.total_time - other.total_time).abs > sort_delta
+        -1
+      elsif self.total_time > other.total_time && (self.total_time - other.total_time).abs > sort_delta
+        1
+      elsif self.call_trees.min_depth < other.call_trees.min_depth
+        1
+      elsif self.call_trees.min_depth > other.call_trees.min_depth
+        -1
+      else
+        self.full_name <=> other.full_name
+      end
+    end
+
+    def to_s
+      "#{self.full_name} (c: #{self.called}, tt: #{self.total_time}, st: #{self.self_time}, wt: #{wait_time}, ct: #{self.children_time})"
+    end
+  end
+end

data/lib/ruby-prof/version.rb

@@ -1,3 +1,3 @@
 module RubyProf
-  VERSION = "1.6.3"
+  VERSION = "1.7.1"
 end

data/ruby-prof.gemspec

@@ -56,9 +56,10 @@ EOF
                    'test/*.rb']
 
   spec.test_files = Dir["test/test_*.rb"]
-  spec.required_ruby_version = '>= 2.7.0'
+  spec.required_ruby_version = '>= 3.0.0'
   spec.date = Time.now.strftime('%Y-%m-%d')
   spec.homepage = 'https://github.com/ruby-prof/ruby-prof'
+  spec.add_development_dependency("base64")
   spec.add_development_dependency('minitest')
   spec.add_development_dependency('rake-compiler')
 end