ruby-prof 1.8.0-x64-mswin64-140

data/test/thread_test.rb

@@ -0,0 +1,229 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require File.expand_path('../test_helper', __FILE__)
+require_relative './call_tree_builder'
+
+# --  Tests ----
+class ThreadTest < TestCase
+  def test_initialize
+    method_info = RubyProf::MethodInfo.new(Array, :size)
+    call_tree = RubyProf::CallTree.new(method_info)
+    thread = RubyProf::Thread.new(call_tree, Thread.current, Fiber.current)
+
+    assert_equal(call_tree, thread.call_tree)
+    assert(thread)
+    assert(thread.id)
+    assert(thread.fiber_id)
+
+    assert_equal(1, thread.methods.size)
+    assert_same(method_info, thread.methods[0])
+  end
+
+  def test_merge
+    call_tree_1 = create_call_tree_1
+    thread_1 = RubyProf::Thread.new(call_tree_1, Thread.current, Fiber.current)
+    assert_equal(6, thread_1.methods.size)
+
+    call_tree_2 = create_call_tree_2
+    thread_2 = RubyProf::Thread.new(call_tree_2, Thread.current, Fiber.current)
+    assert_equal(6, thread_2.methods.size)
+
+    thread_1.merge!(thread_2)
+    assert_equal(7, thread_1.methods.size)
+
+    # Method times
+    assert_in_delta(11.6, thread_1.methods[0].total_time, 0.00001) # root
+    assert_in_delta(4.1, thread_1.methods[1].total_time, 0.00001)  # a
+    assert_in_delta(1.5, thread_1.methods[2].total_time, 0.00001)  # aa
+    assert_in_delta(2.6, thread_1.methods[3].total_time, 0.00001)  # ab
+    assert_in_delta(7.5, thread_1.methods[4].total_time, 0.00001)  # b
+    assert_in_delta(6.6, thread_1.methods[5].total_time, 0.00001)  # bb
+    assert_in_delta(0.9, thread_1.methods[6].total_time, 0.00001)  # ba
+
+    # Root
+    call_tree = call_tree_1
+    assert_equal(:root, call_tree.target.method_name)
+    assert_in_delta(11.6, call_tree.total_time, 0.00001)
+    assert_in_delta(0, call_tree.self_time, 0.00001)
+    assert_in_delta(0.0, call_tree.wait_time, 0.00001)
+    assert_in_delta(11.6, call_tree.children_time, 0.00001)
+
+    # a
+    call_tree = call_tree_1.children[0]
+    assert_equal(:a, call_tree.target.method_name)
+    assert_in_delta(4.1, call_tree.total_time, 0.00001)
+    assert_in_delta(0, call_tree.self_time, 0.00001)
+    assert_in_delta(0.0, call_tree.wait_time, 0.00001)
+    assert_in_delta(4.1, call_tree.children_time, 0.00001)
+
+    # aa
+    call_tree = call_tree_1.children[0].children[0]
+    assert_equal(:aa, call_tree.target.method_name)
+    assert_in_delta(1.5, call_tree.total_time, 0.00001)
+    assert_in_delta(1.5, call_tree.self_time, 0.00001)
+    assert_in_delta(0.0, call_tree.wait_time, 0.00001)
+    assert_in_delta(0.0, call_tree.children_time, 0.00001)
+
+    # ab
+    call_tree = call_tree_1.children[0].children[1]
+    assert_equal(:ab, call_tree.target.method_name)
+    assert_in_delta(2.6, call_tree.total_time, 0.00001)
+    assert_in_delta(2.6, call_tree.self_time, 0.00001)
+    assert_in_delta(0.0, call_tree.wait_time, 0.00001)
+    assert_in_delta(0.0, call_tree.children_time, 0.00001)
+
+    # # b
+    # call_tree = call_tree_1.children[1]
+    # assert_equal(:b, call_tree.target.method_name)
+    # assert_in_delta(7.5, call_tree.total_time, 0.00001)
+    # assert_in_delta(0, call_tree.self_time, 0.00001)
+    # assert_in_delta(0.0, call_tree.wait_time, 0.00001)
+    # assert_in_delta(7.5, call_tree.children_time, 0.00001)
+
+    # bb
+    # call_tree = call_tree_1.children[1].children[0]
+    # assert_equal(:bb, call_tree.target.method_name)
+    # assert_in_delta(6.6, call_tree.total_time, 0.00001)
+    # assert_in_delta(6.6, call_tree.self_time, 0.00001)
+    # assert_in_delta(0.0, call_tree.wait_time, 0.00001)
+    # assert_in_delta(0.0, call_tree.children_time, 0.00001)
+
+    # ba
+    call_tree = call_tree_1.children[1].children[1]
+    assert_equal(:ba, call_tree.target.method_name)
+    assert_in_delta(0.9, call_tree.total_time, 0.00001)
+    assert_in_delta(0.7, call_tree.self_time, 0.00001)
+    assert_in_delta(0.2, call_tree.wait_time, 0.00001)
+    assert_in_delta(0.0, call_tree.children_time, 0.00001)
+  end
+
+  def test_thread_count
+    result = RubyProf::Profile.profile(measure_mode: RubyProf::WALL_TIME) do
+      thread = Thread.new do
+        sleep(1)
+      end
+
+      thread.join
+    end
+    assert_equal(2, result.threads.length)
+  end
+
+  def test_thread_identity
+    profile = RubyProf::Profile.new(measure_mode: RubyProf::WALL_TIME)
+    profile.start
+
+    sleep_thread = Thread.new do
+      sleep(1)
+    end
+    sleep_thread.join
+    result = profile.stop
+
+    thread_ids = result.threads.map {|thread| thread.id}.sort
+    threads = [Thread.current, sleep_thread]
+    assert_equal(2, result.threads.length)
+
+    assert(thread_ids.include?(threads[0].object_id))
+    assert(thread_ids.include?(threads[1].object_id))
+
+    assert_instance_of(Thread, ObjectSpace._id2ref(thread_ids[0]))
+    assert(threads.include?(ObjectSpace._id2ref(thread_ids[0])))
+
+    assert_instance_of(Thread, ObjectSpace._id2ref(thread_ids[1]))
+    assert(threads.include?(ObjectSpace._id2ref(thread_ids[1])))
+  end
+
+  def test_thread_timings
+    profile = RubyProf::Profile.new(measure_mode: RubyProf::WALL_TIME)
+    profile.start
+
+    thread = Thread.new do
+      sleep 0
+      # force it to hit thread.join, below, first
+      # thus forcing sleep(1), below, to be counted as (wall) self_time
+      # since we currently count time "in some other thread" as self.wait_time
+      sleep(1)
+    end
+    thread.join
+    result = profile.stop
+
+    # Check background thread
+    assert_equal(2, result.threads.length)
+
+    rp_thread = result.threads.detect {|t| t.id == thread.object_id}
+    methods = rp_thread.methods.sort.reverse
+
+    method = methods[0]
+    assert_equal('ThreadTest#test_thread_timings', method.full_name)
+    assert_equal(1, method.called)
+    assert_in_delta(1, method.total_time, 0.1)
+    assert_in_delta(0, method.self_time, 0.05)
+    assert_in_delta(0, method.wait_time, 0.05)
+    assert_in_delta(1, method.children_time, 0.1)
+    assert_equal(0, method.call_trees.callers.length)
+
+    method = methods[1]
+    assert_equal('Kernel#sleep', method.full_name)
+    assert_equal(2, method.called)
+    assert_in_delta(1, method.total_time, 0.05)
+    assert_in_delta(1.0, method.self_time, 0.05)
+    assert_in_delta(0, method.wait_time, 0.05)
+    assert_in_delta(0, method.children_time, 0.05)
+
+    assert_equal(1, method.call_trees.callers.length)
+    assert_equal(0, method.call_trees.callees.length)
+
+    # Check foreground thread
+    rp_thread = result.threads.detect {|athread| athread.id == Thread.current.object_id}
+    methods = rp_thread.methods.sort.reverse
+    assert_equal(4, methods.length)
+    methods = methods.sort.reverse
+
+    method = methods[0]
+    assert_equal('ThreadTest#test_thread_timings', method.full_name)
+    # the sub calls to Object#new, when popped,
+    # cause the parent frame to be created for method #test_thread_timings, which means a +1 when it's popped in the end
+    # xxxx a test that shows it the other way, too (never creates parent frame--if that's even possible)
+    assert_equal(1, method.called)
+    assert_in_delta(1, method.total_time, 0.05)
+    assert_in_delta(0, method.self_time, 0.05)
+    assert_in_delta(0, method.wait_time, 0.05)
+    assert_in_delta(1, method.children_time, 0.05)
+
+    assert_equal(0, method.call_trees.callers.length)
+    assert_equal(2, method.call_trees.callees.length)
+
+    method = methods[1]
+    assert_equal('Thread#join', method.full_name)
+    assert_equal(1, method.called)
+    assert_in_delta(1, method.total_time, 0.05)
+    assert_in_delta(0, method.self_time, 0.05)
+    assert_in_delta(1.0, method.wait_time, 0.05)
+    assert_in_delta(0, method.children_time, 0.05)
+
+    assert_equal(1, method.call_trees.callers.length)
+    assert_equal(0, method.call_trees.callees.length)
+
+    method = methods[2]
+    assert_equal('<Class::Thread>#new', method.full_name)
+    assert_equal(1, method.called)
+    assert_in_delta(0, method.total_time, 0.05)
+    assert_in_delta(0, method.self_time, 0.05)
+    assert_in_delta(0, method.wait_time, 0.05)
+    assert_in_delta(0, method.children_time, 0.05)
+
+    assert_equal(1, method.call_trees.callers.length)
+    assert_equal(1, method.call_trees.callees.length)
+
+    method = methods[3]
+    assert_equal('Thread#initialize', method.full_name)
+    assert_equal(1, method.called)
+    assert_in_delta(0, method.total_time, 0.05)
+    assert_in_delta(0, method.self_time, 0.05)
+    assert_in_delta(0, method.wait_time, 0.05)
+    assert_in_delta(0, method.children_time, 0.05)
+
+    assert_equal(1, method.call_trees.callers.length)
+    assert_equal(0, method.call_trees.callees.length)
+  end
+end

data/test/unique_call_path_test.rb

@@ -0,0 +1,123 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require File.expand_path('../test_helper', __FILE__)
+
+class UniqueCallPath
+  def method_a(i)
+    if i==1
+      method_b
+    else
+      method_c
+    end
+  end
+
+  def method_b
+    method_c
+  end
+
+  def method_c
+  end
+
+  def method_k(i)
+    method_a(i)
+  end
+end
+
+
+# --  Tests ----
+class UniqueCallPathTest < TestCase
+  def test_root
+    unique_call_path = UniqueCallPath.new
+
+    result = RubyProf::Profile.profile do
+      unique_call_path.method_a(1)
+    end
+
+    root_call_info = result.threads.first.call_tree
+    assert_equal("UniqueCallPathTest#test_root", root_call_info.target.full_name)
+  end
+
+  def test_root_children
+    unique_call_path = UniqueCallPath.new
+
+    result = RubyProf::Profile.profile do
+      unique_call_path.method_a(1)
+      unique_call_path.method_k(2)
+    end
+
+    root_call_info = result.threads.first.call_tree
+    children = root_call_info.children.sort do |c1, c2|
+      c1.target.full_name <=> c2.target.full_name
+    end
+
+    assert_equal(2, children.length)
+    assert_equal("UniqueCallPath#method_a", children[0].target.full_name)
+    assert_equal("UniqueCallPath#method_k", children[1].target.full_name)
+  end
+
+  def test_children_of
+    unique_call_path = UniqueCallPath.new
+
+    result = RubyProf::Profile.profile do
+      unique_call_path.method_a(1)
+      unique_call_path.method_k(2)
+    end
+
+    root_call_info = result.threads.first.call_tree
+    assert_equal("UniqueCallPathTest#test_children_of", root_call_info.target.full_name)
+
+    call_info_a = root_call_info.children.detect do |call_tree|
+      call_tree.target.full_name == "UniqueCallPath#method_a"
+    end
+    refute_nil(call_info_a)
+
+    _children_of_a = call_info_a.children.inject(Array.new) do |array, c|
+      if c.parent.eql?(call_info_a)
+        array << c
+      end
+      array
+    end
+
+    assert_equal(2, call_info_a.children.length)
+    assert_equal("Integer#==", call_info_a.children[0].target.full_name)
+    assert_equal("UniqueCallPath#method_b", call_info_a.children[1].target.full_name)
+  end
+
+  def test_unique_path
+    unique_call_path = UniqueCallPath.new
+
+    result = RubyProf::Profile.profile do
+      unique_call_path.method_a(1)
+      unique_call_path.method_k(1)
+    end
+
+    root_call_info = result.threads.first.call_tree
+    assert_equal("UniqueCallPathTest#test_unique_path", root_call_info.target.full_name)
+
+    call_info_a = root_call_info.children.detect do |call_tree|
+      call_tree.target.full_name == "UniqueCallPath#method_a"
+    end
+    refute_nil(call_info_a)
+
+    children_of_a = call_info_a.children.reduce(Array.new) do |array, c|
+      if c.parent.eql?(call_info_a)
+        array << c
+      end
+      array
+    end
+
+    children_of_a = children_of_a.sort do |c1, c2|
+      c1.target.full_name <=> c2.target.full_name
+    end
+
+    assert_equal(2, call_info_a.children.length)
+    assert_equal(2, children_of_a.length)
+
+    assert_equal(1, children_of_a[0].called)
+    assert_equal("Integer#==", children_of_a[0].target.full_name)
+
+    assert_equal(1, children_of_a[1].called)
+    assert_equal("UniqueCallPath#method_b", children_of_a[1].target.full_name)
+  end
+end

data/test/yarv_test.rb

@@ -0,0 +1,56 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require File.expand_path('../test_helper', __FILE__)
+
+# tests for bugs reported by users
+class YarvTest < TestCase
+  def setup
+    super
+    define_methods
+  end
+
+  def test_array_push_unoptimized
+    a = nil
+    result = RubyProf::Profile.profile(measure_mode: RubyProf::WALL_TIME) do
+      a = self.array_push_unoptimized
+    end
+    assert_equal 2, a.length
+    assert_equal ["YarvTest#test_array_push_unoptimized", "YarvTest#array_push_unoptimized", 'Array#<<', "Array#push"], result.threads.first.methods.map(&:full_name)
+  end
+
+  def test_array_push_optimized
+    a = nil
+    result = RubyProf::Profile.profile(measure_mode: RubyProf::WALL_TIME) do
+      a = self.array_push_optimized
+    end
+    assert_equal(2, a.length)
+    assert_equal(["YarvTest#test_array_push_optimized", "YarvTest#array_push_optimized", "Array#<<", "Array#push"], result.threads.first.methods.map(&:full_name))
+  end
+
+  private
+
+  def define_methods
+    return if respond_to?(:array_push_optimized)
+    old_compile_option = RubyVM::InstructionSequence.compile_option
+    RubyVM::InstructionSequence.compile_option = {
+      :trace_instruction => true,
+      :specialized_instruction => false
+    }
+    self.class.class_eval <<-"EOM"
+      def array_push_unoptimized
+        a = []
+        a << 1
+        a.push 2
+      end
+    EOM
+    RubyVM::InstructionSequence.compile_option = old_compile_option
+    self.class.class_eval <<-"EOM"
+      def array_push_optimized
+        a = []
+        a << 1
+        a.push 2
+      end
+    EOM
+  end
+end

metadata

@@ -0,0 +1,228 @@
+--- !ruby/object:Gem::Specification
+name: ruby-prof
+version: !ruby/object:Gem::Version
+  version: 1.8.0
+platform: x64-mswin64-140
+authors:
+- Shugo Maeda, Charlie Savage, Roger Pack, Stefan Kaes
+bindir: bin
+cert_chain: []
+date: 2026-02-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: base64
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: ostruct
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: |
+  ruby-prof is a fast code profiler for Ruby. It is a C extension and
+  therefore is many times faster than the standard Ruby profiler. It
+  supports both flat and graph profiles.  For each method, graph profiles
+  show how long the method ran, which methods called it and which
+  methods it called. RubyProf generate both text and html and can output
+  it to standard out or to a file.
+email: shugo@ruby-lang.org, cfis@savagexi.com, rogerdpack@gmail.com, skaes@railsexpress.de
+executables:
+- ruby-prof
+- ruby-prof-check-trace
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGES
+- LICENSE
+- README.md
+- Rakefile
+- bin/ruby-prof
+- bin/ruby-prof-check-trace
+- ext/ruby_prof/extconf.rb
+- ext/ruby_prof/rp_allocation.c
+- ext/ruby_prof/rp_allocation.h
+- ext/ruby_prof/rp_call_tree.c
+- ext/ruby_prof/rp_call_tree.h
+- ext/ruby_prof/rp_call_trees.c
+- ext/ruby_prof/rp_call_trees.h
+- ext/ruby_prof/rp_measure_allocations.c
+- ext/ruby_prof/rp_measure_memory.c
+- ext/ruby_prof/rp_measure_process_time.c
+- ext/ruby_prof/rp_measure_wall_time.c
+- ext/ruby_prof/rp_measurement.c
+- ext/ruby_prof/rp_measurement.h
+- ext/ruby_prof/rp_method.c
+- ext/ruby_prof/rp_method.h
+- ext/ruby_prof/rp_profile.c
+- ext/ruby_prof/rp_profile.h
+- ext/ruby_prof/rp_stack.c
+- ext/ruby_prof/rp_stack.h
+- ext/ruby_prof/rp_thread.c
+- ext/ruby_prof/rp_thread.h
+- ext/ruby_prof/ruby_prof.c
+- ext/ruby_prof/ruby_prof.h
+- ext/ruby_prof/vc/ruby_prof.sln
+- ext/ruby_prof/vc/ruby_prof.vcxproj
+- lib/ruby-prof.rb
+- lib/ruby-prof/assets/call_stack_printer.html.erb
+- lib/ruby-prof/assets/call_stack_printer.png
+- lib/ruby-prof/assets/graph_printer.html.erb
+- lib/ruby-prof/call_tree.rb
+- lib/ruby-prof/call_tree_visitor.rb
+- lib/ruby-prof/compatibility.rb
+- lib/ruby-prof/exclude_common_methods.rb
+- lib/ruby-prof/measurement.rb
+- lib/ruby-prof/method_info.rb
+- lib/ruby-prof/printers/abstract_printer.rb
+- lib/ruby-prof/printers/call_info_printer.rb
+- lib/ruby-prof/printers/call_stack_printer.rb
+- lib/ruby-prof/printers/call_tree_printer.rb
+- lib/ruby-prof/printers/dot_printer.rb
+- lib/ruby-prof/printers/flat_printer.rb
+- lib/ruby-prof/printers/graph_html_printer.rb
+- lib/ruby-prof/printers/graph_printer.rb
+- lib/ruby-prof/printers/multi_printer.rb
+- lib/ruby-prof/profile.rb
+- lib/ruby-prof/rack.rb
+- lib/ruby-prof/task.rb
+- lib/ruby-prof/thread.rb
+- lib/ruby-prof/version.rb
+- lib/unprof.rb
+- ruby-prof.gemspec
+- test/abstract_printer_test.rb
+- test/alias_test.rb
+- test/call_tree_builder.rb
+- test/call_tree_test.rb
+- test/call_tree_visitor_test.rb
+- test/call_trees_test.rb
+- test/compatibility_test.rb
+- test/duplicate_names_test.rb
+- test/dynamic_method_test.rb
+- test/enumerable_test.rb
+- test/exceptions_test.rb
+- test/exclude_methods_test.rb
+- test/exclude_threads_test.rb
+- test/fiber_test.rb
+- test/gc_test.rb
+- test/inverse_call_tree_test.rb
+- test/line_number_test.rb
+- test/marshal_test.rb
+- test/measure_allocations.rb
+- test/measure_allocations_test.rb
+- test/measure_process_time_test.rb
+- test/measure_times.rb
+- test/measure_wall_time_test.rb
+- test/measurement_test.rb
+- test/merge_test.rb
+- test/method_info_test.rb
+- test/multi_printer_test.rb
+- test/no_method_class_test.rb
+- test/pause_resume_test.rb
+- test/prime.rb
+- test/prime_script.rb
+- test/printer_call_stack_test.rb
+- test/printer_call_tree_test.rb
+- test/printer_flat_test.rb
+- test/printer_graph_html_test.rb
+- test/printer_graph_test.rb
+- test/printers_test.rb
+- test/printing_recursive_graph_test.rb
+- test/profile_test.rb
+- test/rack_test.rb
+- test/recursive_test.rb
+- test/scheduler.rb
+- test/singleton_test.rb
+- test/stack_printer_test.rb
+- test/start_stop_test.rb
+- test/test_helper.rb
+- test/thread_test.rb
+- test/unique_call_path_test.rb
+- test/yarv_test.rb
+homepage: https://github.com/ruby-prof/ruby-prof
+licenses:
+- BSD-2-Clause
+metadata:
+  bug_tracker_uri: https://github.com/ruby-prof/ruby-prof/issues
+  changelog_uri: https://github.com/ruby-prof/ruby-prof/blob/master/CHANGES
+  documentation_uri: https://ruby-prof.github.io/
+  source_code_uri: https://github.com/ruby-prof/ruby-prof/tree/v1.8.0
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.6
+specification_version: 4
+summary: Fast Ruby profiler
+test_files:
+- test/test_helper.rb