Module: RubyProf

Defined in:
lib/ruby-prof/compatibility.rb,
lib/ruby-prof.rb,
lib/ruby-prof/task.rb,
lib/ruby-prof/thread.rb,
lib/ruby-prof/walker.rb,
lib/ruby-prof/profile.rb,
lib/ruby-prof/version.rb,
lib/ruby-prof/call_info.rb,
lib/ruby-prof/method_info.rb,
lib/ruby-prof/call_info_visitor.rb,
lib/ruby-prof/aggregate_call_info.rb,
lib/ruby-prof/printers/dot_printer.rb,
lib/ruby-prof/printers/flat_printer.rb,
lib/ruby-prof/printers/graph_printer.rb,
lib/ruby-prof/printers/multi_printer.rb,
lib/ruby-prof/printers/abstract_printer.rb,
lib/ruby-prof/printers/call_info_printer.rb,
lib/ruby-prof/printers/call_tree_printer.rb,
lib/ruby-prof/printers/call_stack_printer.rb,
lib/ruby-prof/printers/graph_html_printer.rb,
lib/ruby-prof/profile/exclude_common_methods.rb,
lib/ruby-prof/printers/fast_call_tree_printer.rb,
lib/ruby-prof/printers/flame_graph_html_printer.rb,
lib/ruby-prof/printers/flame_graph_json_printer.rb,
lib/ruby-prof/printers/flat_printer_with_line_numbers.rb,
ext/ruby_prof/ruby_prof.c

Overview

The call info visitor class does a depth-first traversal across a list of method infos. At each call_info node, the visitor executes the block provided in the #visit method. The block is passed two parameters, the event and the call_info instance. Event will be either :enter or :exit.

visitor = RubyProf::CallInfoVisitor.new(result.threads.first.top_call_infos)

method_names = Array.new

visitor.visit do |call_info, event|
  method_names << call_info.target.full_name if event == :enter
end

puts method_names

Defined Under Namespace

Modules: Measure Classes: AbstractPrinter, AggregateCallInfo, CallInfo, CallInfoPrinter, CallInfoVisitor, CallStackPrinter, CallTreePrinter, DotPrinter, FastCallTreePrinter, FlameGraphHtmlPrinter, FlameGraphJsonPrinter, FlatPrinter, FlatPrinterWithLineNumbers, GraphHtmlPrinter, GraphPrinter, MethodInfo, MultiPrinter, Profile, ProfileTask, Thread, Walker

Constant Summary collapse

VERSION =

Based off ruby-prof 0.16.2

"0.0.1"
MEMORY = 
INT2NUM(MEASURE_MEMORY)
MEMORY_ENABLED = 
MEASURE_MEMORY_ENABLED
GC_RUNS = 
INT2NUM(MEASURE_GC_RUNS)
GC_RUNS_ENABLED = 
MEASURE_GC_RUNS_ENABLED
GC_TIME = 
INT2NUM(MEASURE_GC_TIME)
GC_TIME_ENABLED = 
MEASURE_GC_TIME_ENABLED
CPU_TIME = 
INT2NUM(MEASURE_CPU_TIME)
CPU_TIME_ENABLED = 
Qtrue
WALL_TIME = 
INT2NUM(MEASURE_WALL_TIME)
WALL_TIME_ENABLED = 
Qtrue
ALLOCATIONS = 
INT2NUM(MEASURE_ALLOCATIONS)
ALLOCATIONS_ENABLED = 
MEASURE_ALLOCATIONS_ENABLED
CLOCKS_PER_SEC = 
INT2NUM(CLOCKS_PER_SEC)
PROCESS_TIME = 
INT2NUM(MEASURE_PROCESS_TIME)
PROCESS_TIME_ENABLED = 
Qtrue

Class Method Summary collapse

Class Method Details

.cpu_frequency ⇒ Object

Measurements



6
7
8
 
# File 'lib/ruby-prof/compatibility.rb', line 6

def self.cpu_frequency
  Measure::CpuTime.frequency
end

.exclude_threads ⇒ Object

call-seq: exclude_threads -> exclude_threads

Returns threads ruby-prof should exclude from profiling



96
97
98
 
# File 'lib/ruby-prof/compatibility.rb', line 96

def self.exclude_threads
  @exclude_threads ||= Array.new
end

.exclude_threads=(value) ⇒ Object

call-seq: exclude_threads= -> void

Specifies what threads ruby-prof should exclude from profiling



105
106
107
 
# File 'lib/ruby-prof/compatibility.rb', line 105

def self.exclude_threads=(value)
  @exclude_threads = value
end

.figure_measure_mode ⇒ Object

Checks if the user specified the clock mode via the RUBY_PROF_MEASURE_MODE environment variable



41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
 
# File 'lib/ruby-prof.rb', line 41

def self.figure_measure_mode
  case ENV["RUBY_PROF_MEASURE_MODE"]
  when "wall", "wall_time"
    RubyProf.measure_mode = RubyProf::WALL_TIME
  when "cpu", "cpu_time"
    RubyProf.measure_mode = RubyProf::CPU_TIME
  when "allocations"
    RubyProf.measure_mode = RubyProf::ALLOCATIONS
  when "memory"
    RubyProf.measure_mode = RubyProf::MEMORY
  when "process", "process_time"
    RubyProf.measure_mode = RubyProf::PROCESS_TIME
  when "gc_time"
    RubyProf.measure_mode = RubyProf::GC_TIME
  when "gc_runs"
    RubyProf.measure_mode = RubyProf::GC_RUNS
  else
    # the default is defined in the measure_mode reader
  end
end

.measure_allocations ⇒ Object 



10
11
12
 
# File 'lib/ruby-prof/compatibility.rb', line 10

def self.measure_allocations
  Measure::Allocations.measure
end

.measure_cpu_time ⇒ Object 



14
15
16
 
# File 'lib/ruby-prof/compatibility.rb', line 14

def self.measure_cpu_time
  Measure::CpuTime.measure
end

.measure_gc_runs ⇒ Object 



18
19
20
 
# File 'lib/ruby-prof/compatibility.rb', line 18

def self.measure_gc_runs
  Measure::GcRuns.measure
end

.measure_gc_time ⇒ Object 



22
23
24
 
# File 'lib/ruby-prof/compatibility.rb', line 22

def self.measure_gc_time
  Measure::GcTime.measure
end

.measure_memory ⇒ Object 



26
27
28
 
# File 'lib/ruby-prof/compatibility.rb', line 26

def self.measure_memory
  Measure::Memory.measure
end

.measure_mode ⇒ Object

call-seq: measure_mode -> measure_mode

Returns what ruby-prof is measuring. Valid values include:

*RubyProf::WALL_TIME - Measure wall time using gettimeofday on Linx and GetLocalTime on Windows. This is default. *RubyProf::PROCESS_TIME - Measure process time. It is implemented using the clock functions in the C Runtime library. *RubyProf::CPU_TIME - Measure time using the CPU clock counter. This mode is only supported on Pentium or PowerPC platforms. *RubyProf::ALLOCATIONS - Measure object allocations. This requires a patched Ruby interpreter. *RubyProf::MEMORY - Measure memory size. This requires a patched Ruby interpreter. *RubyProf::GC_RUNS - Measure number of garbage collections. This requires a patched Ruby interpreter. *RubyProf::GC_TIME - Measure time spent doing garbage collection. This requires a patched Ruby interpreter.*/



51
52
53
 
# File 'lib/ruby-prof/compatibility.rb', line 51

def self.measure_mode
  measure_modes.first
end

.measure_mode=(value) ⇒ Object

call-seq: measure_mode=value -> void

Specifies what ruby-prof should measure. Valid values include:

*RubyProf::WALL_TIME - Measure wall time using gettimeofday on Linx and GetLocalTime on Windows. This is default. *RubyProf::PROCESS_TIME - Measure process time. It is implemented using the clock functions in the C Runtime library. *RubyProf::CPU_TIME - Measure time using the CPU clock counter. This mode is only supported on Pentium or PowerPC platforms. *RubyProf::ALLOCATIONS - Measure object allocations. This requires a patched Ruby interpreter. *RubyProf::MEMORY - Measure memory size. This requires a patched Ruby interpreter. *RubyProf::GC_RUNS - Measure number of garbage collections. This requires a patched Ruby interpreter. *RubyProf::GC_TIME - Measure time spent doing garbage collection. This requires a patched Ruby interpreter.*/



67
68
69
 
# File 'lib/ruby-prof/compatibility.rb', line 67

def self.measure_mode=(value)
  self.measure_modes = [value]
end

.measure_mode_string ⇒ Object 



79
80
81
82
83
84
85
86
87
88
89
 
# File 'lib/ruby-prof/compatibility.rb', line 79

def self.measure_mode_string
  case measure_mode
  when WALL_TIME    then "wall_time"
  when CPU_TIME     then "cpu_time"
  when PROCESS_TIME then "process_time_time"
  when ALLOCATIONS  then "allocations"
  when MEMORY       then "memory"
  when GC_TIME      then "gc_time"
  when GC_RUNS      then "gc_runs"
  end
end

.measure_modes ⇒ Object 



71
72
73
 
# File 'lib/ruby-prof/compatibility.rb', line 71

def self.measure_modes
  @measure_modes ||= [RubyProf::WALL_TIME]
end

.measure_modes=(value) ⇒ Object 



75
76
77
 
# File 'lib/ruby-prof/compatibility.rb', line 75

def self.measure_modes=(value)
  @measure_modes = value
end

.measure_process_time ⇒ Object 



30
31
32
 
# File 'lib/ruby-prof/compatibility.rb', line 30

def self.measure_process_time
  Measure::ProcessTime.measure
end

.measure_wall_time ⇒ Object 



34
35
36
 
# File 'lib/ruby-prof/compatibility.rb', line 34

def self.measure_wall_time
  Measure::WallTime.measure
end

.pause ⇒ Object 



122
123
124
125
126
 
# File 'lib/ruby-prof/compatibility.rb', line 122

def self.pause
  ensure_running!
  disable_gc_stats_if_needed
  @profile.pause
end

.profile(options = {}, &block) ⇒ Object

Profile a block



151
152
153
154
155
156
157
158
 
# File 'lib/ruby-prof/compatibility.rb', line 151

def self.profile(options = {}, &block)
  ensure_not_running!
  gc_stat_was_enabled = enable_gc_stats_if_needed
  options = { measure_modes: [measure_mode], exclude_threads: exclude_threads }.merge!(options)
  result = Profile.profile(options, &block)
  disable_gc_stats_if_needed(gc_stat_was_enabled)
  result
end

.resume ⇒ Object 



136
137
138
139
140
 
# File 'lib/ruby-prof/compatibility.rb', line 136

def self.resume
  ensure_running!
  enable_gc_stats_if_needed
  @profile.resume
end

.running? ⇒ Boolean

Returns:

  • (Boolean) 


128
129
130
131
132
133
134
 
# File 'lib/ruby-prof/compatibility.rb', line 128

def self.running?
  if defined?(@profile) and @profile
    @profile.running?
  else
    false
  end
end

.start ⇒ Object 



115
116
117
118
119
120
 
# File 'lib/ruby-prof/compatibility.rb', line 115

def self.start
  ensure_not_running!
  @profile = Profile.new(measure_modes: measure_modes, exclude_threads: exclude_threads)
  enable_gc_stats_if_needed
  @profile.start
end

.start_script(script) ⇒ Object

Profiling



110
111
112
113
 
# File 'lib/ruby-prof/compatibility.rb', line 110

def self.start_script(script)
  start
  load script
end

.stop ⇒ Object 



142
143
144
145
146
147
148
 
# File 'lib/ruby-prof/compatibility.rb', line 142

def self.stop
  ensure_running!
  result = @profile.stop
  disable_gc_stats_if_needed
  @profile = nil
  result
end