Class: RubyProf::CallInfo

Inherits:
Object
  • Object
show all
Defined in:
ext/ruby_prof/rp_call_info.c,
lib/ruby-prof/call_info.rb,
ext/ruby_prof/rp_call_info.c

Overview

RubyProf::CallInfo is a helper class used by RubyProf::MethodInfo to keep track of which child methods were called and how long they took to execute.

Instance Attribute Summary collapse

Instance Method Summary collapse

Instance Attribute Details

#recursive ⇒ Object

Returns the value of attribute recursive.



5
6
7
 
# File 'lib/ruby-prof/call_info.rb', line 5

def recursive
  @recursive
end

Instance Method Details

#add_self_time(call_info) ⇒ nil

adds self time from call_info to self.

Returns:

  • (nil) 


236
237
238
239
240
241
242
243
244
 
# File 'ext/ruby_prof/rp_call_info.c', line 236

static VALUE
prof_call_info_add_self_time(VALUE self, VALUE other)
{
    prof_call_info_t *result = prof_get_call_info(self);
    prof_call_info_t *other_info = prof_get_call_info(other);

    result->self_time += other_info->self_time;
    return Qnil;
}

#add_total_time(call_info) ⇒ nil

adds total time time from call_info to self.

Returns:

  • (nil) 


210
211
212
213
214
215
216
217
218
 
# File 'ext/ruby_prof/rp_call_info.c', line 210

static VALUE
prof_call_info_add_total_time(VALUE self, VALUE other)
{
    prof_call_info_t *result = prof_get_call_info(self);
    prof_call_info_t *other_info = prof_get_call_info(other);

    result->total_time += other_info->total_time;
    return Qnil;
}

#add_wait_time(call_info) ⇒ nil

adds wait time from call_info to self.

Returns:

  • (nil) 


263
264
265
266
267
268
269
270
271
 
# File 'ext/ruby_prof/rp_call_info.c', line 263

static VALUE
prof_call_info_add_wait_time(VALUE self, VALUE other)
{
    prof_call_info_t *result = prof_get_call_info(self);
    prof_call_info_t *other_info = prof_get_call_info(other);

    result->wait_time += other_info->wait_time;
    return Qnil;
}

#call_sequence ⇒ Object 



26
27
28
29
30
 
# File 'lib/ruby-prof/call_info.rb', line 26

def call_sequence
  @call_sequence ||= begin
    stack.map {|method| method.full_name}.join('->')
  end
end

#called ⇒ Integer

Returns the total amount of times this method was called.

Returns:

  • (Integer) 


154
155
156
157
158
159
 
# File 'ext/ruby_prof/rp_call_info.c', line 154

static VALUE
prof_call_info_called(VALUE self)
{
    prof_call_info_t *result = prof_get_call_info(self);
    return INT2NUM(result->called);
}

#called= ⇒ Object

Sets the call count to n.



165
166
167
168
169
170
171
 
# File 'ext/ruby_prof/rp_call_info.c', line 165

static VALUE
prof_call_info_set_called(VALUE self, VALUE called)
{
    prof_call_info_t *result = prof_get_call_info(self);
    result->called = NUM2INT(called);
    return called;
}

#children ⇒ Hash

Returns an array of call info objects of methods that this method called (ie, children).

Returns:

  • (Hash) 


316
317
318
319
320
321
322
323
324
325
326
 
# File 'ext/ruby_prof/rp_call_info.c', line 316

static VALUE
prof_call_info_children(VALUE self)
{
    prof_call_info_t *call_info = prof_get_call_info(self);
    if (call_info->children == Qnil)
    {
      call_info->children = rb_ary_new();
      st_foreach(call_info->call_infos, prof_call_info_collect_children, call_info->children);
    }
    return call_info->children;
}

#children_time ⇒ Object 



7
8
9
10
11
 
# File 'lib/ruby-prof/call_info.rb', line 7

def children_time
  children.inject(0) do |sum, call_info|
    sum += call_info.total_time
  end
end

#depth ⇒ Integer

returns the depth of this call info in the call graph

Returns:

  • (Integer) 


177
178
179
180
181
182
 
# File 'ext/ruby_prof/rp_call_info.c', line 177

static VALUE
prof_call_info_depth(VALUE self)
{
  prof_call_info_t *result = prof_get_call_info(self);
  return rb_int_new(result->depth);
}

#eliminate! ⇒ Object

eliminate call info from the call tree. adds self and wait time to parent and attaches called methods to parent. merges call trees for methods called from both praent end self.



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

def eliminate!
  # puts "eliminating #{self}"
  return unless parent
  parent.add_self_time(self)
  parent.add_wait_time(self)
  children.each do |kid|
    if call = parent.find_call(kid)
      call.merge_call_tree(kid)
    else
      parent.children << kid
      # $stderr.puts "setting parent of #{kid}\nto #{parent}"
      kid.parent = parent
    end
  end
  parent.children.delete(self)
end

#find_call(other) ⇒ Object

find a sepcific call in list of children. returns nil if not found. note: there can’t be more than one child with a given target method. in other words: x.children.grep{|y|y.target==m}.size <= 1 for all method infos m and call infos x



63
64
65
66
67
 
# File 'lib/ruby-prof/call_info.rb', line 63

def find_call(other)
  matching = children.select { |kid| kid.target == other.target }
  raise "inconsistent call tree" unless matching.size <= 1
  matching.first
end

#line_no ⇒ Integer

returns the line number of the method

Returns:

  • (Integer) 


188
189
190
191
192
193
 
# File 'ext/ruby_prof/rp_call_info.c', line 188

static VALUE
prof_call_info_line(VALUE self)
{
  prof_call_info_t *result = prof_get_call_info(self);
  return rb_int_new(result->line);
}

#merge_call_tree(other) ⇒ Object

merge two call trees. adds self, wait, and total time of other to self and merges children of other into children of self.



70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
 
# File 'lib/ruby-prof/call_info.rb', line 70

def merge_call_tree(other)
  # $stderr.puts "merging #{self}\nand #{other}"
  self.called += other.called
  add_self_time(other)
  add_wait_time(other)
  add_total_time(other)
  other.children.each do |other_kid|
    if kid = find_call(other_kid)
      # $stderr.puts "merging kids"
      kid.merge_call_tree(other_kid)
    else
      other_kid.parent = self
      children << other_kid
    end
  end
  other.children.clear
  other.target.call_infos.delete(other)
end

#parent ⇒ Object

Returns the call_infos parent call_info object (the method that called this method).



277
278
279
280
281
282
283
284
285
 
# File 'ext/ruby_prof/rp_call_info.c', line 277

static VALUE
prof_call_info_parent(VALUE self)
{
    prof_call_info_t *result = prof_get_call_info(self);
    if (result->parent)
      return prof_call_info_wrap(result->parent);
    else
      return Qnil;
}

#parent= ⇒ Object

Changes the parent of self to new_parent and returns it.



291
292
293
294
295
296
297
298
299
300
 
# File 'ext/ruby_prof/rp_call_info.c', line 291

static VALUE
prof_call_info_set_parent(VALUE self, VALUE new_parent)
{
    prof_call_info_t *result = prof_get_call_info(self);
    if (new_parent == Qnil)
      result->parent = NULL;
    else
      result->parent = prof_get_call_info(new_parent);
    return prof_call_info_parent(self);
}

#root? ⇒ Boolean

Returns:

  • (Boolean) 


32
33
34
 
# File 'lib/ruby-prof/call_info.rb', line 32

def root?
  self.parent.nil?
end

#self_time ⇒ Float

Returns the total amount of time spent in this method.

Returns:

  • (Float) 


224
225
226
227
228
229
230
 
# File 'ext/ruby_prof/rp_call_info.c', line 224

static VALUE
prof_call_info_self_time(VALUE self)
{
    prof_call_info_t *result = prof_get_call_info(self);

    return rb_float_new(result->self_time);
}

#stack ⇒ Object 



13
14
15
16
17
18
19
20
21
22
23
24
 
# File 'lib/ruby-prof/call_info.rb', line 13

def stack
  @stack ||= begin
    methods = Array.new
    call_info = self

    while call_info
      methods << call_info.target
      call_info = call_info.parent
    end
    methods.reverse
  end
end

#called ⇒ MethodInfo

Returns the target method.

Returns:



139
140
141
142
143
144
145
146
147
148
 
# File 'ext/ruby_prof/rp_call_info.c', line 139

static VALUE
prof_call_info_target(VALUE self)
{
    /* Target is a pointer to a method_info - so we have to be careful
       about the GC.  We will wrap the method_info but provide no
       free method so the underlying object is not freed twice! */

    prof_call_info_t *result = prof_get_call_info(self);
    return prof_method_wrap(result->target);
}

#to_s ⇒ Object 



36
37
38
 
# File 'lib/ruby-prof/call_info.rb', line 36

def to_s
  "#{self.target.full_name} (c: #{self.called}, tt: #{self.total_time}, st: #{self.self_time}, ct: #{self.children_time})"
end

#total_time ⇒ Float

Returns the total amount of time spent in this method and its children.

Returns:

  • (Float) 


199
200
201
202
203
204
 
# File 'ext/ruby_prof/rp_call_info.c', line 199

static VALUE
prof_call_info_total_time(VALUE self)
{
    prof_call_info_t *result = prof_get_call_info(self);
    return rb_float_new(result->total_time);
}

#wait_time ⇒ Float

Returns the total amount of time this method waited for other threads.

Returns:

  • (Float) 


250
251
252
253
254
255
256
 
# File 'ext/ruby_prof/rp_call_info.c', line 250

static VALUE
prof_call_info_wait_time(VALUE self)
{
    prof_call_info_t *result = prof_get_call_info(self);

    return rb_float_new(result->wait_time);
}