ruby-prof 1.3.0-x64-mingw32 → 1.4.3-x64-mingw32

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0e7a5ed3eff6d7d963f459a572dd63561423abb6d8911076e086e3588befb37b
-  data.tar.gz: b4bf7cc5ec23482ccbcb103b6c7ab87c8614da0076d6a43f4848d6cd8aee3178
+  metadata.gz: ff6376af9ff0bca0c82428adbe82fac0b61baaa885ec1c0838f00615b473c5a5
+  data.tar.gz: 5501219e23555b6b4d695e3539ea65ef1491f5387ed19be63e8ccda546196304
 SHA512:
-  metadata.gz: 4797da262fc687b47bea5c33bdcfdd102197afb8a3ff441b00a5444bc06de4deb83421569b6e8f815381a385e79edc08c4339b2d3ab26f9f7c920a155c00f080
-  data.tar.gz: bc891673567736bef06b12eb72514425261a678ad9d33ad709835e1e1cffd265c4657ba436a2e28486a45fa35fd678117ac2a2882c564fbfb334eb1edcec3918
+  metadata.gz: f177dccca89487aad943de3b049b40929c2576fcda0fc05e6c41cbcbef99b78e9c42717297341edf15bafd78da8596b2d5a44522a899ddf7437645f621aae9c2
+  data.tar.gz: 0450be219e2a2caa86c75ecccb8384ecfcb4293aff82e4a6b3a7165b8a09bad25cc9e4629d0d0340887a455e854d0e42d432b4f96ba13c359adcf4ad424e54a8

data/CHANGES

@@ -1,3 +1,45 @@
+1.4.3 (2021-02-15)
+=====================
+* Remove trailing spaces (sergioro)
+* Enable loading ruby_prof.so from ext directory for development purposes (sergioro)
+* Create temp directory for test output (sergioro)
+* Fix minitest warning about using MT_CPU instead of N (sergioro)
+* Fix minitest warning "Use assert_nil if expecting nil"  (sergioro)
+* Fix file permissions (sergioro)
+* Fix failing test by forcing GC to run (Charlie Savage)
+* Switch to GitHub actions (Charlie Savage)
+* Switch to C11 (Charlie Savage)
+* Greatly slim down library size by removing symbols on GCC (Charlie Savage)
+
+1.4.2 (2020-11-3)
+=====================
+* Do NOT use Ruby 2.7.0 and 2.7.1 with ruby-prof. A bug in those versions of ruby causes ruby-prof to
+not work. Version 2.7.2 works correctly.
+* Fix crash caused be reallocating an internal stack that keeps tracks of frames *after* getting a reference to the
+top frame in the stack (Charlie Savage).
+* Fix bug where the flat printer did not correctly report the correct measurement mode.
+
+1.4.1 (2020-05-14)
+=====================
+* Fix compiling on older versions of gcc that do not default to c99 (Charlie Savage)
+
+1.4.0 (2020-05-12)
+=====================
+* API change - remove merge_fibers support since it resulted in incorrect results or crashes (Charlie Savage)
+* Fix crash when profiling memory usage (Charlie Savage)
+* When tracing execution correctly print out newobj tracepoint events (Charlie Savage)
+* Remove no longer needed code for building extensions (Charlie Savage)
+
+1.3.2 (2020-04-19)
+=====================
+* Fix rack profiler so it is thread safe (Charlie Savage)
+* Fix loading of prebuilt binaries on mingw64 to use Ruby's major and minor version (Charlie Savage)
+
+1.3.1 (2020-03-11)
+=====================
+* Add max_percent and filter_by options to flat printer (Sean McGivern)
+* Include binary in mingw64 build (Charlie Savage)
+
 1.3.0 (2020-02-22)
 =====================
 * Update C code to use newer RTypedData API versus older RData API.

data/README.rdoc

@@ -1,5 +1,5 @@
 = ruby-prof
 
-{<img src="https://travis-ci.org/ruby-prof/ruby-prof.png?branch=master" alt="Build Status" />}[https://travis-ci.org/ruby-prof/ruby-prof]
+![ruby-prof](https://github.com/ruby-prof/ruby-prof/workflows/ruby-prof/badge.svg)
 
 For an overview of ruby-prof please see https://ruby-prof.github.io

data/Rakefile

@@ -6,13 +6,6 @@ require "rake/testtask"
 require "rdoc/task"
 require "date"
 require "rake/clean"
-begin
-  require "bundler/setup"
-  Bundler::GemHelper.install_tasks
-  [:build, :install, :release].each {|t| Rake::Task[t].enhance [:rdoc] }
-rescue LoadError
-  $stderr.puts "Install bundler to get support for simplified gem publishing"
-end
 
 # To release a version of ruby-prof:
 #   * Update lib/ruby-prof/version.rb
@@ -23,10 +16,6 @@ end
 #   * rake package to create the gems
 #   * Tag the release (git tag 0.10.1)
 #   * Push to ruybgems.org (gem push pkg/<gem files>)
-# For a ruby only release, just run
-#   * rake release
-# it will push changes to github, tag the release, build the package and upload it to rubygems.org
-# and in case you forgot to increment the version number or have uncommitted changes, it will refuse to work
 
 GEM_NAME = 'ruby-prof'
 SO_NAME = 'ruby_prof'
@@ -38,9 +27,9 @@ Rake::ExtensionTask.new do |ext|
   ext.gem_spec = default_spec
   ext.name = SO_NAME
   ext.ext_dir = "ext/#{SO_NAME}"
-  ext.lib_dir = "lib/#{RUBY_VERSION}"
+  ext.lib_dir = "lib/#{Gem::Version.new(RUBY_VERSION).segments[0..1].join('.')}"
   ext.cross_compile = true
-  ext.cross_platform = ['x86-mingw32', 'x64-mingw32']
+  ext.cross_platform = ['x64-mingw32']
 end
 
 # Rake task to build the default package
@@ -58,7 +47,6 @@ if RUBY_PLATFORM.match(/win32|mingw32/)
   win_spec = default_spec.clone
   win_spec.platform = Gem::Platform::CURRENT
   win_spec.files += Dir.glob('lib/**/*.so')
-  win_spec.instance_variable_set(:@cache_file, nil) # Hack to work around gem issue
 
   # Unset extensions
   win_spec.extensions = nil

data/ext/ruby_prof/extconf.rb

@@ -1,36 +1,22 @@
 require "mkmf"
 
-if RUBY_ENGINE != "ruby"
-  STDERR.puts("\n\n***** This gem is MRI-specific. It does not support #{RUBY_ENGINE}. *****\n\n")
-  exit(1)
+# Let's go with a modern version of C! want to intermix declarations and code (ie, don't define
+# all variables at the top of the method). If using Visual Studio, you'll need 2019 version
+# 16.8 or higher
+if RUBY_PLATFORM =~ /mswin/
+  $CFLAGS += ' /std:c11'
+else
+  $CFLAGS += ' -std=c11'
 end
 
-if Gem::Version.new(RUBY_VERSION) < Gem::Version.new('2.4.0')
-  STDERR.puts("\n\n***** Ruby version #{RUBY_VERSION} is no longer supported. Please upgrade to 2.3 or higher. *****\n\n")
-  exit(1)
+# For gcc add -s to strip symbols, reducing library size from 17MB to 78KB (at least on Windows with mingw64)
+if RUBY_PLATFORM !~ /mswin/
+  $LDFLAGS += ' -s'
 end
 
-# For the love of bitfields...
-$CFLAGS += ' -std=c99'
-
-# And since we are using C99
-CONFIG['warnflags'].gsub!('-Wdeclaration-after-statement', '')
-
-def add_define(name, value = nil)
-  if value
-    $defs.push("-D#{name}=#{value}")
-  else
-    $defs.push("-D#{name}")
-  end
-end
-
-def windows?
-  RbConfig::CONFIG['host_os'] =~ /mswin|mingw/
+# And since we are using C99 we want to disable Ruby sending these warnings to gcc
+if CONFIG['warnflags']
+  CONFIG['warnflags'].gsub!('-Wdeclaration-after-statement', '')
 end
 
-add_define("RUBY_PROF_RUBY_VERSION", RUBY_VERSION.split('.')[0..2].inject(0){|v,d| v*100+d.to_i})
-
-# This function was added in Ruby 2.5, so once Ruby 2.4 is no longer supported this can be removed
-have_func('rb_tracearg_callee_id', ["ruby.h"])
-
 create_makefile("ruby_prof")

data/ext/ruby_prof/rp_allocation.c

@@ -141,7 +141,7 @@ static const rb_data_type_t allocation_type =
     },
     .data = NULL,
     .flags = RUBY_TYPED_FREE_IMMEDIATELY
-}; 
+};
 
 VALUE prof_allocation_wrap(prof_allocation_t* allocation)
 {

data/ext/ruby_prof/rp_call_trees.c

@@ -219,7 +219,7 @@ VALUE prof_call_trees_callers(VALUE self)
         }
     }
 
-    VALUE result = rb_ary_new_capa(callers->num_entries);
+    VALUE result = rb_ary_new_capa((long)callers->num_entries);
     rb_st_foreach(callers, prof_call_trees_collect_aggregates, result);
     rb_st_free_table(callers);
     return result;
@@ -239,7 +239,7 @@ VALUE prof_call_trees_callees(VALUE self)
         rb_st_foreach((*call_tree)->children, prof_call_trees_collect_callees, (st_data_t)callees);
     }
 
-    VALUE result = rb_ary_new_capa(callees->num_entries);
+    VALUE result = rb_ary_new_capa((long)callees->num_entries);
     rb_st_foreach(callees, prof_call_trees_collect_aggregates, result);
     rb_st_free_table(callees);
     return result;

data/ext/ruby_prof/rp_measure_allocations.c

@@ -10,7 +10,7 @@ VALUE total_allocated_objects_key;
 
 static double measure_allocations_via_gc_stats(rb_trace_arg_t* trace_arg)
 {
-    return rb_gc_stat(total_allocated_objects_key);
+    return (double)rb_gc_stat(total_allocated_objects_key);
 }
 
 static double measure_allocations_via_tracing(rb_trace_arg_t* trace_arg)

data/ext/ruby_prof/rp_measure_process_time.c

@@ -24,7 +24,7 @@ static double measure_process_time(rb_trace_arg_t* trace_arg)
     userTimeInt.LowPart = userTime.dwLowDateTime;
     userTimeInt.HighPart = userTime.dwHighDateTime;
 
-    return sysTimeInt.QuadPart + userTimeInt.QuadPart;
+    return (double)(sysTimeInt.QuadPart + userTimeInt.QuadPart);
 #elif !defined(CLOCK_PROCESS_CPUTIME_ID)
     struct rusage usage;
     getrusage(RUSAGE_SELF, &usage);

data/ext/ruby_prof/rp_measure_wall_time.c

@@ -17,7 +17,7 @@ static double measure_wall_time(rb_trace_arg_t* trace_arg)
 #if defined(_WIN32)
     LARGE_INTEGER time;
     QueryPerformanceCounter(&time);
-    return time.QuadPart;
+    return (double)time.QuadPart;
 #elif defined(__APPLE__)
     return mach_absolute_time();// * (uint64_t)mach_timebase.numer / (uint64_t)mach_timebase.denom;
 #elif defined(__linux__)

data/ext/ruby_prof/rp_measurement.c

@@ -100,7 +100,7 @@ static const rb_data_type_t measurement_type =
     },
     .data = NULL,
     .flags = RUBY_TYPED_FREE_IMMEDIATELY
-}; 
+};
 
 VALUE prof_measurement_wrap(prof_measurement_t* measurement)
 {

data/ext/ruby_prof/rp_method.c

@@ -253,7 +253,7 @@ static const rb_data_type_t method_info_type =
     },
     .data = NULL,
     .flags = RUBY_TYPED_FREE_IMMEDIATELY
-}; 
+};
 
 VALUE prof_method_wrap(prof_method_t* method)
 {
@@ -488,4 +488,4 @@ void rp_init_method_info()
 
     rb_define_method(cRpMethodInfo, "_dump_data", prof_method_dump, 0);
     rb_define_method(cRpMethodInfo, "_load_data", prof_method_load, 1);
-}
+}

data/ext/ruby_prof/rp_method.h

@@ -9,35 +9,35 @@
 
 extern VALUE cRpMethodInfo;
 
-// Source relation bit offsets. 
+// Source relation bit offsets.
 enum {
-    kModuleIncludee = 0x1,                    // Included in module 
-    kClassSingleton = 0x2,                    // Singleton of a class 
-    kModuleSingleton = 0x4,                   // Singleton of a module 
-    kObjectSingleton = 0x8,                   // Singleton of an object 
-    kOtherSingleton = 0x10                    // Singleton of unkown object 
+    kModuleIncludee = 0x1,                    // Included in module
+    kClassSingleton = 0x2,                    // Singleton of a class
+    kModuleSingleton = 0x4,                   // Singleton of a module
+    kObjectSingleton = 0x8,                   // Singleton of an object
+    kOtherSingleton = 0x10                    // Singleton of unkown object
 };
 
-// Profiling information for each method. 
-// Excluded methods have no call_trees, source_klass, or source_file. 
+// 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_call_trees_t* call_trees;   // Call infos that call this method 
-    st_table* allocations_table;            // Tracks object allocations 
+    struct prof_call_trees_t* call_trees;   // Call infos that call this method
+    st_table* allocations_table;            // Tracks object allocations
 
-    st_data_t key;                          // Table key 
-    unsigned int klass_flags;               // Information about the type of class 
-    VALUE klass;                            // Resolved klass 
-    VALUE klass_name;                       // Resolved klass name for this method 
-    VALUE method_name;                      // Resolved method name for this method 
+    st_data_t key;                          // Table key
+    unsigned int klass_flags;               // Information about the type of class
+    VALUE klass;                            // Resolved klass
+    VALUE klass_name;                       // Resolved klass name for this method
+    VALUE method_name;                      // Resolved method name for this method
 
-    VALUE object;                           // Cached ruby object 
+    VALUE object;                           // Cached ruby object
 
     bool recursive;
-    int visits;                             // Current visits on the stack 
-    VALUE source_file;                      // Source file 
-    int source_line;                        // Line number 
+    int visits;                             // Current visits on the stack
+    VALUE source_file;                      // Source file
+    int source_line;                        // Line number
 
     prof_measurement_t* measurement;        // Stores measurement data for this method
 } prof_method_t;

data/ext/ruby_prof/rp_profile.c

@@ -65,25 +65,19 @@ static const char* get_event_name(rb_event_flag_t event)
         return "fiber-switch";
     case RUBY_EVENT_RAISE:
         return "raise";
+    case RUBY_INTERNAL_EVENT_NEWOBJ:
+        return "newobj";
     default:
         return "unknown";
     }
 }
 
-VALUE get_fiber(prof_profile_t* profile)
-{
-    if (profile->merge_fibers)
-        return rb_thread_current();
-    else
-        return rb_fiber_current();
-}
-
 thread_data_t* check_fiber(prof_profile_t* profile, double measurement)
 {
     thread_data_t* result = NULL;
 
-    /* Get the current thread and fiber information. */
-    VALUE fiber = get_fiber(profile);
+    // Get the current fiber
+    VALUE fiber = rb_fiber_current();
 
     /* We need to switch the profiling context if we either had none before,
      we don't merge fibers and the fiber ids differ, or the thread ids differ. */
@@ -144,11 +138,7 @@ prof_method_t* check_method(VALUE profile, rb_trace_arg_t* trace_arg, rb_event_f
     if (klass == cProfile)
         return NULL;
 
-#ifdef HAVE_RB_TRACEARG_CALLEE_ID
     VALUE msym = rb_tracearg_callee_id(trace_arg);
-#else
-    VALUE msym = rb_tracearg_method_id(trace_arg);
-#endif
 
     st_data_t key = method_key(klass, msym);
 
@@ -164,7 +154,7 @@ prof_method_t* check_method(VALUE profile, rb_trace_arg_t* trace_arg, rb_event_f
         int source_line = (event != RUBY_EVENT_C_CALL ? FIX2INT(rb_tracearg_lineno(trace_arg)) : 0);
         result = create_method(profile, key, klass, msym, source_file, source_line);
     }
-    
+
     return result;
 }
 
@@ -172,7 +162,7 @@ prof_method_t* check_method(VALUE profile, rb_trace_arg_t* trace_arg, rb_event_f
 static void prof_trace(prof_profile_t* profile, rb_trace_arg_t* trace_arg, double measurement)
 {
     static VALUE last_fiber = Qnil;
-    VALUE fiber = get_fiber(profile);
+    VALUE fiber = rb_fiber_current();
 
     rb_event_flag_t event = rb_tracearg_event_flag(trace_arg);
     const char* event_name = get_event_name(event);
@@ -180,11 +170,7 @@ static void prof_trace(prof_profile_t* profile, rb_trace_arg_t* trace_arg, doubl
     VALUE source_file = rb_tracearg_path(trace_arg);
     int source_line = FIX2INT(rb_tracearg_lineno(trace_arg));
 
-#ifdef HAVE_RB_TRACEARG_CALLEE_ID
     VALUE msym = rb_tracearg_callee_id(trace_arg);
-#else
-    VALUE msym = rb_tracearg_method_id(trace_arg);
-#endif
 
     unsigned int klass_flags;
     VALUE klass = rb_tracearg_defined_class(trace_arg);
@@ -259,13 +245,13 @@ static void prof_event_hook(VALUE trace_point, void* data)
                 {
                     frame = prof_frame_push(thread_data->stack, call_tree, measurement, RTEST(profile_t->paused));
                 }
-                
+
                 thread_data->call_tree = call_tree;
             }
-            
+
             frame->source_file = rb_tracearg_path(trace_arg);
             frame->source_line = FIX2INT(rb_tracearg_lineno(trace_arg));
-            
+
             break;
         }
         case RUBY_EVENT_CALL:
@@ -288,7 +274,7 @@ static void prof_event_hook(VALUE trace_point, void* data)
             }
             else if (!frame && thread_data->call_tree)
             {
-                // There is no current parent - likely we have returned out of the highest level method we have profiled so far. 
+                // There is no current parent - likely we have returned out of the highest level method we have profiled so far.
                 // This can happen with enumerators (see fiber_test.rb). So create a new dummy parent.
                 prof_method_t* parent_method = check_parent_method(profile, thread_data);
                 parent_call_tree = prof_call_tree_create(parent_method, NULL, Qnil, 0);
@@ -427,7 +413,7 @@ static void prof_profile_mark(void* data)
         rb_st_foreach(profile->exclude_methods_tbl, prof_profile_mark_methods, 0);
 }
 
-/* Freeing the profile creates a cascade of freeing. It frees its threads table, which frees 
+/* Freeing the profile creates a cascade of freeing. It frees its threads table, which frees
    each thread and its associated call treee and methods. */
 static void prof_profile_ruby_gc_free(void* data)
 {
@@ -487,7 +473,6 @@ static VALUE prof_allocate(VALUE klass)
     profile->include_threads_tbl = NULL;
     profile->running = Qfalse;
     profile->allow_exceptions = false;
-    profile->merge_fibers = false;
     profile->exclude_methods_tbl = method_table_create();
     profile->running = Qfalse;
     profile->tracepoints = rb_ary_new();
@@ -529,9 +514,6 @@ prof_stop_threads(prof_profile_t* profile)
                       If not specified, defaults to RubyProf::WALL_TIME.
    allow_exceptions:  Whether to raise exceptions encountered during profiling,
                       or to suppress all exceptions during profiling
-   merge_fibers:      Whether profiling data for a given thread's fibers should all be
-                      subsumed under a single entry. Basically only useful to produce
-                      callgrind profiles.
    track_allocations: Whether to track object allocations while profiling. True or false.
    exclude_common:    Exclude common methods from the profile. True or false.
    exclude_threads:   Threads to exclude from the profiling results.
@@ -546,7 +528,6 @@ static VALUE prof_initialize(int argc, VALUE* argv, VALUE self)
     VALUE include_threads = Qnil;
     VALUE exclude_common = Qnil;
     VALUE allow_exceptions = Qfalse;
-    VALUE merge_fibers = Qfalse;
     VALUE track_allocations = Qfalse;
 
     int i;
@@ -566,7 +547,6 @@ static VALUE prof_initialize(int argc, VALUE* argv, VALUE self)
             mode = rb_hash_aref(mode_or_options, ID2SYM(rb_intern("measure_mode")));
             track_allocations = rb_hash_aref(mode_or_options, ID2SYM(rb_intern("track_allocations")));
             allow_exceptions = rb_hash_aref(mode_or_options, ID2SYM(rb_intern("allow_exceptions")));
-            merge_fibers = rb_hash_aref(mode_or_options, ID2SYM(rb_intern("merge_fibers")));
             exclude_common = rb_hash_aref(mode_or_options, ID2SYM(rb_intern("exclude_common")));
             exclude_threads = rb_hash_aref(mode_or_options, ID2SYM(rb_intern("exclude_threads")));
             include_threads = rb_hash_aref(mode_or_options, ID2SYM(rb_intern("include_threads")));
@@ -587,7 +567,6 @@ static VALUE prof_initialize(int argc, VALUE* argv, VALUE self)
     }
     profile->measurer = prof_get_measurer(NUM2INT(mode), track_allocations == Qtrue);
     profile->allow_exceptions = (allow_exceptions == Qtrue);
-    profile->merge_fibers = (merge_fibers == Qtrue);
 
     if (exclude_threads != Qnil)
     {
@@ -679,7 +658,7 @@ static VALUE prof_start(VALUE self)
 
     profile->running = Qtrue;
     profile->paused = Qfalse;
-    profile->last_thread_data = threads_table_insert(profile, get_fiber(profile));
+    profile->last_thread_data = threads_table_insert(profile, rb_fiber_current());
 
     /* open trace file if environment wants it */
     trace_file_name = getenv("RUBY_PROF_TRACE");
@@ -769,11 +748,7 @@ static VALUE prof_stop(VALUE self)
     {
         if (trace_file != stderr && trace_file != stdout)
         {
-#ifdef _MSC_VER
-            _fcloseall();
-#else
             fclose(trace_file);
-#endif
         }
         trace_file = NULL;
     }