ruby-prof 1.5.0-x64-mingw-ucrt → 1.6.1-x64-mingw-ucrt

data/ext/ruby_prof/rp_profile.c

@@ -103,17 +103,15 @@ static int excludes_method(st_data_t key, prof_profile_t* profile)
             method_table_lookup(profile->exclude_methods_tbl, key) != NULL);
 }
 
-static prof_method_t* create_method(VALUE profile, st_data_t key, VALUE klass, VALUE msym, VALUE source_file, int source_line)
+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, klass, msym, source_file, source_line);
-
-    prof_profile_t* profile_t = prof_get_profile(profile);
-    method_table_insert(profile_t->last_thread_data->method_table, result->key, result);
+    prof_method_t* result = prof_method_create(profile->object, klass, msym, source_file, source_line);
+    method_table_insert(profile->last_thread_data->method_table, result->key, result);
 
     return result;
 }
 
-static prof_method_t* check_parent_method(VALUE profile, thread_data_t* thread_data)
+static prof_method_t* check_parent_method(prof_profile_t* profile, thread_data_t* thread_data)
 {
     VALUE msym = ID2SYM(rb_intern("_inserted_parent_"));
     st_data_t key = method_key(cProfile, msym);
@@ -128,7 +126,7 @@ static prof_method_t* check_parent_method(VALUE profile, thread_data_t* thread_d
     return result;
 }
 
-prof_method_t* check_method(VALUE profile, rb_trace_arg_t* trace_arg, rb_event_flag_t event, thread_data_t* thread_data)
+prof_method_t* check_method(prof_profile_t* profile, rb_trace_arg_t* trace_arg, rb_event_flag_t event, thread_data_t* thread_data)
 {
     VALUE klass = rb_tracearg_defined_class(trace_arg);
 
@@ -142,8 +140,7 @@ prof_method_t* check_method(VALUE profile, rb_trace_arg_t* trace_arg, rb_event_f
 
     st_data_t key = method_key(klass, msym);
 
-    prof_profile_t* profile_t = prof_get_profile(profile);
-    if (excludes_method(key, profile_t))
+    if (excludes_method(key, profile))
         return NULL;
 
     prof_method_t* result = method_table_lookup(thread_data->method_table, key);
@@ -197,17 +194,16 @@ static void prof_trace(prof_profile_t* profile, rb_trace_arg_t* trace_arg, doubl
 
 static void prof_event_hook(VALUE trace_point, void* data)
 {
-    VALUE profile = (VALUE)data;
-    prof_profile_t* profile_t = prof_get_profile(profile);
+    prof_profile_t* profile = (prof_profile_t*)(data);
 
     rb_trace_arg_t* trace_arg = rb_tracearg_from_tracepoint(trace_point);
-    double measurement = prof_measure(profile_t->measurer, trace_arg);
+    double measurement = prof_measure(profile->measurer, trace_arg);
     rb_event_flag_t event = rb_tracearg_event_flag(trace_arg);
     VALUE self = rb_tracearg_self(trace_arg);
 
     if (trace_file != NULL)
     {
-        prof_trace(profile_t, trace_arg, measurement);
+        prof_trace(profile, trace_arg, measurement);
     }
 
     /* Special case - skip any methods from the mProf
@@ -215,7 +211,7 @@ static void prof_event_hook(VALUE trace_point, void* data)
     if (self == mProf)
         return;
 
-    thread_data_t* thread_data = check_fiber(profile_t, measurement);
+    thread_data_t* thread_data = check_fiber(profile, measurement);
 
     if (!thread_data->trace)
         return;
@@ -247,7 +243,7 @@ static void prof_event_hook(VALUE trace_point, void* data)
                 // This is the first method to be profiled
                 else
                 {
-                    frame = prof_frame_push(thread_data->stack, call_tree, measurement, RTEST(profile_t->paused));
+                    frame = prof_frame_push(thread_data->stack, call_tree, measurement, RTEST(profile->paused));
                 }
 
                 thread_data->call_tree = call_tree;
@@ -301,7 +297,7 @@ static void prof_event_hook(VALUE trace_point, void* data)
                 thread_data->call_tree = call_tree;
 
             // Push a new frame onto the stack for a new c-call or ruby call (into a method)
-            prof_frame_t* next_frame = prof_frame_push(thread_data->stack, call_tree, measurement, RTEST(profile_t->paused));
+            prof_frame_t* next_frame = prof_frame_push(thread_data->stack, call_tree, measurement, RTEST(profile->paused));
             next_frame->source_file = method->source_file;
             next_frame->source_line = method->source_line;
             break;
@@ -327,7 +323,7 @@ static void prof_event_hook(VALUE trace_point, void* data)
 
             prof_method_t* method = prof_find_method(thread_data->stack, source_file, source_line);
             if (method)
-                prof_allocate_increment(method, trace_arg);
+                prof_allocate_increment(method->allocations_table, trace_arg);
 
             break;
         }
@@ -342,12 +338,12 @@ void prof_install_hook(VALUE self)
                                                RUBY_EVENT_CALL | RUBY_EVENT_RETURN |
                                                RUBY_EVENT_C_CALL | RUBY_EVENT_C_RETURN |
                                                RUBY_EVENT_LINE,
-                                               prof_event_hook, (void*)self);
+                                               prof_event_hook, profile);
     rb_ary_push(profile->tracepoints, event_tracepoint);
 
     if (profile->measurer->track_allocations)
     {
-        VALUE allocation_tracepoint = rb_tracepoint_new(Qnil, RUBY_INTERNAL_EVENT_NEWOBJ, prof_event_hook, (void*)self);
+        VALUE allocation_tracepoint = rb_tracepoint_new(Qnil, RUBY_INTERNAL_EVENT_NEWOBJ, prof_event_hook, profile);
         rb_ary_push(profile->tracepoints, allocation_tracepoint);
     }
 
@@ -404,9 +400,10 @@ static int prof_profile_mark_methods(st_data_t key, st_data_t value, st_data_t r
 static void prof_profile_mark(void* data)
 {
     prof_profile_t* profile = (prof_profile_t*)data;
-    rb_gc_mark(profile->tracepoints);
-    rb_gc_mark(profile->running);
-    rb_gc_mark(profile->paused);
+    rb_gc_mark_movable(profile->object);
+    rb_gc_mark_movable(profile->tracepoints);
+    rb_gc_mark_movable(profile->running);
+    rb_gc_mark_movable(profile->paused);
 
     // If GC stress is true (useful for debugging), when threads_table_create is called in the
     // allocate method Ruby will immediately call this mark method. Thus the threads_tbl will be NULL.
@@ -417,6 +414,15 @@ static void prof_profile_mark(void* data)
         rb_st_foreach(profile->exclude_methods_tbl, prof_profile_mark_methods, 0);
 }
 
+void prof_profile_compact(void* data)
+{
+    prof_profile_t* profile = (prof_profile_t*)data;
+    profile->object = rb_gc_location(profile->object);
+    profile->tracepoints = rb_gc_location(profile->tracepoints);
+    profile->running = rb_gc_location(profile->running);
+    profile->paused = rb_gc_location(profile->paused);
+}
+
 /* 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)
@@ -462,6 +468,7 @@ static const rb_data_type_t profile_type =
         .dmark = prof_profile_mark,
         .dfree = prof_profile_ruby_gc_free,
         .dsize = prof_profile_size,
+        .dcompact = prof_profile_compact
     },
     .data = NULL,
     .flags = RUBY_TYPED_FREE_IMMEDIATELY
@@ -472,6 +479,7 @@ static VALUE prof_allocate(VALUE klass)
     VALUE result;
     prof_profile_t* profile;
     result = TypedData_Make_Struct(klass, prof_profile_t, &profile_type, profile);
+    profile->object = result;
     profile->threads_tbl = threads_table_create();
     profile->exclude_threads_tbl = NULL;
     profile->include_threads_tbl = NULL;
@@ -510,9 +518,9 @@ prof_stop_threads(prof_profile_t* profile)
 
 /* call-seq:
    new()
-   new(options)
+   new(keyword_args)
 
-   Returns a new profiler. Possible options for the options hash are:
+   Returns a new profiler. Possible keyword arguments include:
 
    measure_mode:      Measure mode. Specifies the profile measure mode.
                       If not specified, defaults to RubyProf::WALL_TIME.
@@ -525,78 +533,55 @@ prof_stop_threads(prof_profile_t* profile)
                       all other threads. */
 static VALUE prof_initialize(int argc, VALUE* argv, VALUE self)
 {
+    VALUE keywords;
+    rb_scan_args_kw(RB_SCAN_ARGS_KEYWORDS, argc, argv, ":", &keywords);
+
+    ID table[] = {rb_intern("measure_mode"),
+                  rb_intern("track_allocations"),
+                  rb_intern("allow_exceptions"),
+                  rb_intern("exclude_common"),
+                  rb_intern("exclude_threads"),
+                  rb_intern("include_threads") };
+    VALUE values[6];
+    rb_get_kwargs(keywords, table, 0, 6, values);
+
+    VALUE mode = values[0] == Qundef ? INT2NUM(MEASURE_WALL_TIME) : values[0];
+    VALUE track_allocations = values[1] == Qtrue ? Qtrue : Qfalse;
+    VALUE allow_exceptions = values[2] == Qtrue ? Qtrue : Qfalse;
+    VALUE exclude_common = values[3] == Qtrue ? Qtrue : Qfalse;
+    VALUE exclude_threads = values[4];
+    VALUE include_threads = values[5];
+
+    Check_Type(mode, T_FIXNUM);
     prof_profile_t* profile = prof_get_profile(self);
-    VALUE mode_or_options;
-    VALUE mode = Qnil;
-    VALUE exclude_threads = Qnil;
-    VALUE include_threads = Qnil;
-    VALUE exclude_common = Qnil;
-    VALUE allow_exceptions = Qfalse;
-    VALUE track_allocations = Qfalse;
-
-    int i;
-
-    switch (rb_scan_args(argc, argv, "02", &mode_or_options, &exclude_threads))
-    {
-    case 0:
-        break;
-    case 1:
-        if (FIXNUM_P(mode_or_options))
-        {
-            mode = mode_or_options;
-        }
-        else
-        {
-            Check_Type(mode_or_options, T_HASH);
-            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")));
-            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")));
-        }
-        break;
-    case 2:
-        Check_Type(exclude_threads, T_ARRAY);
-        break;
-    }
-
-    if (mode == Qnil)
-    {
-        mode = INT2NUM(MEASURE_WALL_TIME);
-    }
-    else
-    {
-        Check_Type(mode, T_FIXNUM);
-    }
-    profile->measurer = prof_measurer_create(NUM2INT(mode), track_allocations == Qtrue);
-    profile->allow_exceptions = (allow_exceptions == Qtrue);
+    profile->measurer = prof_measurer_create(NUM2INT(mode), RB_TEST(track_allocations));
+    profile->allow_exceptions = RB_TEST(allow_exceptions);
 
-    if (exclude_threads != Qnil)
+    if (exclude_threads != Qundef)
     {
         Check_Type(exclude_threads, T_ARRAY);
         assert(profile->exclude_threads_tbl == NULL);
         profile->exclude_threads_tbl = threads_table_create();
-        for (i = 0; i < RARRAY_LEN(exclude_threads); i++)
+        for (int i = 0; i < RARRAY_LEN(exclude_threads); i++)
         {
             VALUE thread = rb_ary_entry(exclude_threads, i);
             rb_st_insert(profile->exclude_threads_tbl, thread, Qtrue);
         }
     }
 
-    if (include_threads != Qnil)
+    if (include_threads != Qundef)
     {
         Check_Type(include_threads, T_ARRAY);
         assert(profile->include_threads_tbl == NULL);
         profile->include_threads_tbl = threads_table_create();
-        for (i = 0; i < RARRAY_LEN(include_threads); i++)
+        for (int i = 0; i < RARRAY_LEN(include_threads); i++)
         {
             VALUE thread = rb_ary_entry(include_threads, i);
             rb_st_insert(profile->include_threads_tbl, thread, Qtrue);
         }
     }
 
-    if (RTEST(exclude_common))
+    if (RB_TEST(exclude_common))
     {
         prof_exclude_common_methods(self);
     }
@@ -820,7 +805,7 @@ static VALUE prof_remove_thread(VALUE self, VALUE thread)
        ..
      end
 */
-static VALUE prof_profile_object(VALUE self)
+static VALUE prof_profile_instance(VALUE self)
 {
     int result;
     prof_profile_t* profile = prof_get_profile(self);
@@ -856,7 +841,7 @@ static VALUE prof_profile_object(VALUE self)
 */
 static VALUE prof_profile_class(int argc, VALUE* argv, VALUE klass)
 {
-    return prof_profile_object(rb_class_new_instance(argc, argv, cProfile));
+    return prof_profile_instance(rb_class_new_instance(argc, argv, cProfile));
 }
 
 /* call-seq:
@@ -927,7 +912,7 @@ void rp_init_profile(void)
 
     rb_define_singleton_method(cProfile, "profile", prof_profile_class, -1);
     rb_define_method(cProfile, "initialize", prof_initialize, -1);
-    rb_define_method(cProfile, "profile", prof_profile_object, 0);
+    rb_define_method(cProfile, "profile", prof_profile_instance, 0);
     rb_define_method(cProfile, "start", prof_start, 0);
     rb_define_method(cProfile, "stop", prof_stop, 0);
     rb_define_method(cProfile, "resume", prof_resume, 0);

data/ext/ruby_prof/rp_profile.h

@@ -12,6 +12,7 @@ extern VALUE cProfile;
 
 typedef struct prof_profile_t
 {
+    VALUE object;
     VALUE running;
     VALUE paused;
 

data/ext/ruby_prof/rp_thread.c

@@ -58,18 +58,18 @@ void prof_thread_mark(void* data)
     thread_data_t* thread = (thread_data_t*)data;
 
     if (thread->object != Qnil)
-        rb_gc_mark(thread->object);
+        rb_gc_mark_movable(thread->object);
 
     rb_gc_mark(thread->fiber);
 
     if (thread->methods != Qnil)
-        rb_gc_mark(thread->methods);
+        rb_gc_mark_movable(thread->methods);
 
     if (thread->fiber_id != Qnil)
-        rb_gc_mark(thread->fiber_id);
+        rb_gc_mark_movable(thread->fiber_id);
 
     if (thread->thread_id != Qnil)
-        rb_gc_mark(thread->thread_id);
+        rb_gc_mark_movable(thread->thread_id);
 
     if (thread->call_tree)
         prof_call_tree_mark(thread->call_tree);
@@ -77,6 +77,15 @@ void prof_thread_mark(void* data)
     rb_st_foreach(thread->method_table, mark_methods, 0);
 }
 
+void prof_thread_compact(void* data)
+{
+    thread_data_t* thread = (thread_data_t*)data;
+    thread->object = rb_gc_location(thread->object);
+    thread->methods = rb_gc_location(thread->methods);
+    thread->fiber_id = rb_gc_location(thread->fiber_id);
+    thread->thread_id = rb_gc_location(thread->thread_id);
+}
+
 static void prof_thread_free(thread_data_t* thread_data)
 {
     /* Has this method object been accessed by Ruby?  If
@@ -126,6 +135,7 @@ static const rb_data_type_t thread_type =
         .dmark = prof_thread_mark,
         .dfree = prof_thread_ruby_gc_free,
         .dsize = prof_thread_size,
+        .dcompact = prof_thread_compact
     },
     .data = NULL,
     .flags = RUBY_TYPED_FREE_IMMEDIATELY

data/ext/ruby_prof/vc/ruby_prof.vcxproj

@@ -66,7 +66,7 @@
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
     <TargetExt>.so</TargetExt>
-    <OutDir>$(SolutionDir)\..\..\..\lib\</OutDir>
+    <OutDir>$(SolutionDir)\..</OutDir>
   </PropertyGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
     <ClCompile>

data/lib/ruby-prof/compatibility.rb

@@ -96,4 +96,18 @@ module RubyProf
   def self.ensure_not_running!
     raise(RuntimeError, "RubyProf is already running") if running?
   end
+
+  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
+  end
 end

data/lib/ruby-prof/printers/abstract_printer.rb

@@ -50,7 +50,7 @@ module RubyProf
     # options - Hash of print options. Note that each printer can
     # define its own set of options.
     #
-    #   :min_percent - Number 0 to 100 that specifes the minimum
+    #   :min_percent - Number 0 to 100 that specifies the minimum
     #                  %self (the methods self time divided by the
     #                  overall total time) that a method must take
     #                  for it to be printed out in the report.

data/lib/ruby-prof/printers/call_tree_printer.rb

@@ -27,7 +27,7 @@ module RubyProf
 
     def determine_event_specification_and_value_scale
       @event_specification = "events: "
-      case RubyProf.measure_mode
+      case @result.measure_mode
         when RubyProf::PROCESS_TIME
           @value_scale = RubyProf::CLOCKS_PER_SEC
           @event_specification << 'process_time'

data/lib/ruby-prof/printers/multi_printer.rb

@@ -6,16 +6,16 @@ module RubyProf
   # profile, a call stack profile and a graph profile.
   class MultiPrinter
     def initialize(result, printers = [:flat, :graph_html])
-      @flat_printer = FlatPrinter.new(result) if printers.include?(:flat)
+      @flat_printer = printers.include?(:flat) ? FlatPrinter.new(result) : nil
 
-      @graph_printer = GraphPrinter.new(result) if printers.include?(:graph)
-      @graph_html_printer = GraphHtmlPrinter.new(result) if printers.include?(:graph_html)
+      @graph_printer = printers.include?(:graph) ? GraphPrinter.new(result) : nil
+      @graph_html_printer = printers.include?(:graph_html) ? GraphHtmlPrinter.new(result) : nil
 
-      @tree_printer = CallTreePrinter.new(result) if printers.include?(:tree)
-      @call_info_printer = CallInfoPrinter.new(result) if printers.include?(:call_tree)
+      @tree_printer = printers.include?(:tree) ? CallTreePrinter.new(result) : nil
+      @call_info_printer = printers.include?(:call_tree) ? CallInfoPrinter.new(result) : nil
 
-      @stack_printer = CallStackPrinter.new(result) if printers.include?(:stack)
-      @dot_printer = DotPrinter.new(result) if printers.include?(:dot)
+      @stack_printer = printers.include?(:stack) ? CallStackPrinter.new(result) : nil
+      @dot_printer = printers.include?(:dot) ? DotPrinter.new(result) : nil
     end
 
     def self.needs_dir?
@@ -28,7 +28,7 @@ module RubyProf
     def print(options)
       validate_print_params(options)
 
-      @profile = options.delete(:profile) || "profile"
+      @file_name = options.delete(:profile) || "profile"
       @directory = options.delete(:path) || File.expand_path(".")
 
       print_to_flat(options) if @flat_printer
@@ -44,36 +44,36 @@ module RubyProf
 
     # the name of the flat profile file
     def flat_report
-      "#{@directory}/#{@profile}.flat.txt"
+      "#{@directory}/#{@file_name}.flat.txt"
     end
 
     # the name of the graph profile file
     def graph_report
-      "#{@directory}/#{@profile}.graph.txt"
+      "#{@directory}/#{@file_name}.graph.txt"
     end
 
     def graph_html_report
-      "#{@directory}/#{@profile}.graph.html"
+      "#{@directory}/#{@file_name}.graph.html"
     end
 
     # the name of the callinfo profile file
     def call_info_report
-      "#{@directory}/#{@profile}.call_tree.txt"
+      "#{@directory}/#{@file_name}.call_tree.txt"
     end
 
     # the name of the callgrind profile file
     def tree_report
-      "#{@directory}/#{@profile}.callgrind.out.#{$$}"
+      "#{@directory}/#{@file_name}.callgrind.out.#{$$}"
     end
 
     # the name of the call stack profile file
     def stack_report
-      "#{@directory}/#{@profile}.stack.html"
+      "#{@directory}/#{@file_name}.stack.html"
     end
 
     # the name of the call stack profile file
     def dot_report
-      "#{@directory}/#{@profile}.dot"
+      "#{@directory}/#{@file_name}.dot"
     end
 
     def print_to_flat(options)
@@ -101,12 +101,12 @@ module RubyProf
     end
 
     def print_to_tree(options)
-      @tree_printer.print(options.merge(:path => @directory, :profile => @profile))
+      @tree_printer.print(options.merge(:path => @directory, :profile => @file_name))
     end
 
     def print_to_stack(options)
       File.open(stack_report, "wb") do |file|
-        @stack_printer.print(file, options.merge(:graph => "#{@profile}.graph.html"))
+        @stack_printer.print(file, options.merge(:graph => "#{@file_name}.graph.html"))
       end
     end
 

data/lib/ruby-prof/profile.rb

@@ -23,14 +23,14 @@ module RubyProf
       ExcludeCommonMethods.apply!(self)
     end
 
-    def exclude_methods!(mod, *method_or_methods)
-      [method_or_methods].flatten.each do |name|
-        exclude_method!(mod, name)
+    def exclude_methods!(mod, *method_names)
+      [method_names].flatten.each do |method_name|
+        exclude_method!(mod, method_name)
       end
     end
 
-    def exclude_singleton_methods!(mod, *method_or_methods)
-      exclude_methods!(mod.singleton_class, *method_or_methods)
+    def exclude_singleton_methods!(mod, *method_names)
+      exclude_methods!(mod.singleton_class, *method_names)
     end
 
     # call-seq:

data/lib/ruby-prof/rack.rb

@@ -6,7 +6,6 @@ module Rack
     def initialize(app, options = {})
       @app = app
       @options = options
-      @options[:min_percent] ||= 1
 
       @tmpdir = options[:path] || Dir.tmpdir
       FileUtils.mkdir_p(@tmpdir)
@@ -26,14 +25,19 @@ module Rack
       if should_profile?(request.path)
         begin
           result = nil
-          data = ::RubyProf::Profile.profile(profiling_options) do
+          profile = ::RubyProf::Profile.profile(profiling_options) do
             result = @app.call(env)
           end
 
+          if @options[:merge_fibers]
+            profile.merge!
+          end
+
+
           path = request.path.gsub('/', '-')
           path.slice!(0)
 
-          print(data, path)
+          print(profile, path)
           result
         end
       else
@@ -54,39 +58,45 @@ module Rack
     end
 
     def profiling_options
-      options = {}
-      options[:measure_mode] = ::RubyProf.measure_mode
-      options[:exclude_threads] =
-        if @options[:ignore_existing_threads]
-          Thread.list.select{|t| t != Thread.current}
-        else
-          ::RubyProf.exclude_threads
-        end
-      if @options[:request_thread_only]
-        options[:include_threads] = [Thread.current]
+      result = {}
+      result[:measure_mode] = @options[:measure_mode] || ::RubyProf::WALL_TIME
+      result[:track_allocations] = @options[:track_allocations] || false
+      result[:exclude_common] = @options[:exclude_common] || false
+
+      if @options[:ignore_existing_threads]
+        result[:exclude_threads] = Thread.list.select {|thread| thread != Thread.current}
       end
-      if @options[:merge_fibers]
-        options[:merge_fibers] = true
+
+      if @options[:request_thread_only]
+        result[:include_threads] = [Thread.current]
       end
-      options
+
+      result
+    end
+
+    def print_options
+      result = {}
+      result[:min_percent] = @options[:min_percent] || 1
+      result[:sort_method] = @options[:sort_method] || :total_time
+      result
     end
 
-    def print(data, path)
+    def print(profile, path)
       @printer_klasses.each do |printer_klass, base_name|
-        printer = printer_klass.new(data)
+        printer = printer_klass.new(profile)
 
         if base_name.respond_to?(:call)
           base_name = base_name.call
         end
 
         if printer_klass == ::RubyProf::MultiPrinter
-          printer.print(@options.merge(:profile => "#{path}-#{base_name}"))
+          printer.print(print_options.merge(:profile => "#{path}-#{base_name}"))
         elsif printer_klass == ::RubyProf::CallTreePrinter
-          printer.print(@options.merge(:profile => "#{path}-#{base_name}"))
+          printer.print(print_options.merge(:profile => "#{path}-#{base_name}"))
         else
           file_name = ::File.join(@tmpdir, "#{path}-#{base_name}")
           ::File.open(file_name, 'wb') do |file|
-            printer.print(file, @options)
+            printer.print(file, print_options)
           end
         end
       end

data/lib/ruby-prof/version.rb

@@ -1,3 +1,3 @@
 module RubyProf
-  VERSION = "1.5.0"
+  VERSION = "1.6.1"
 end

data/test/abstract_printer_test.rb

@@ -5,6 +5,7 @@ require File.expand_path('../test_helper', __FILE__)
 
 class AbstractPrinterTest < TestCase
   def setup
+    super
     @result = {}
     @printer = RubyProf::AbstractPrinter.new(@result)
     @options = {}