Class: MemoryTracker::GcStat

Inherits:
Object
  • Object
show all
Includes:
Enumerable
Defined in:
lib/memory_tracker/gc_stat.rb

Constant Summary collapse

RUBY22_TO_CANONICAL_MAPPING = 
{ total_allocated_objects: :total_allocated_object,
  total_freed_objects:     :total_freed_object,
  heap_allocated_pages:    :heap_used,
  heap_live_slots:         :heap_live_num,
  heap_free_slots:         :heap_free_num,
  heap_final_slots:        :heap_final_num,
  heap_sorted_length:      :heap_length
}
CANONICAL_TO_RUBY22_MAPPING = 
RUBY22_TO_CANONICAL_MAPPING.invert

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(rss, vsize) ⇒ GcStat

Returns a new instance of GcStat.



16
17
18
 
# File 'lib/memory_tracker/gc_stat.rb', line 16

def initialize(rss, vsize)
  @stats = GC.stat.merge({ :rss => rss, :vsize => vsize})
end

Class Method Details

.canonical_key_name(key) ⇒ Object 



52
53
54
55
56
57
58
59
 
# File 'lib/memory_tracker/gc_stat.rb', line 52

def self.canonical_key_name(key)
  canonical = key
  case RUBY_VERSION
  when /\A2\.2\./
    canonical = RUBY22_TO_CANONICAL_MAPPING.fetch(key, key)
  end
  canonical
end

.current_version_key_name(key) ⇒ Object 



61
62
63
64
65
66
67
68
 
# File 'lib/memory_tracker/gc_stat.rb', line 61

def self.current_version_key_name(key)
  current_key_name = key
  case RUBY_VERSION
  when /\A2\.2\./
    current_key_name = CANONICAL_TO_RUBY22_MAPPING.fetch(key, key)
  end
  current_key_name
end

.gcdiff(before, after) ⇒ Object 



74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
 
# File 'lib/memory_tracker/gc_stat.rb', line 74

def self.gcdiff(before, after)
  return {} unless (before && before[:total_allocated_object] && before[:total_freed_object])
  return {} unless (after && after[:total_allocated_object] && after[:total_freed_object])
  diff = {}
  b = before.clone
  a = after.clone
  diff[:num_alloc] = a[:total_allocated_object] - b[:total_allocated_object]
  diff[:num_heaps] = a[:heap_used]
  [ a, b ].each do |x|
    x.delete(:heap_increment)
    x.delete(:heap_length)
    x.delete(:heap_final_num)
    x[:in_use] = x.delete(:total_allocated_object) - x.delete(:total_freed_object)
  end
  b.each_key do |key|
    diff[key] = a[key] - b[key]
  end
  diff
end

.heap_used ⇒ Object 



70
71
72
 
# File 'lib/memory_tracker/gc_stat.rb', line 70

def self.heap_used
  GC.stat[current_version_key_name(:heap_used)]
end

Instance Method Details

#[](key) ⇒ Object 



40
41
42
 
# File 'lib/memory_tracker/gc_stat.rb', line 40

def [](key)
  @stats[current_version_key_name(key)]
end

#canonical_key_name(key) ⇒ Object 



44
45
46
 
# File 'lib/memory_tracker/gc_stat.rb', line 44

def canonical_key_name(key)
  self.class.canonical_key_name(key)
end

#current_version_key_name(key) ⇒ Object 



48
49
50
 
# File 'lib/memory_tracker/gc_stat.rb', line 48

def current_version_key_name(key)
  self.class.current_version_key_name(key)
end

#each(&block) ⇒ Object 



20
21
22
23
24
 
# File 'lib/memory_tracker/gc_stat.rb', line 20

def each(&block)
  @stats.each do |k, v|
    yield canonical_key_name(k), v
  end
end

#keys ⇒ Object 



26
27
28
 
# File 'lib/memory_tracker/gc_stat.rb', line 26

def keys
  @stats.keys
end

#ordered_keys ⇒ Object 



30
31
32
 
# File 'lib/memory_tracker/gc_stat.rb', line 30

def ordered_keys
  @stats.keys.map { |k| canonical_key_name(k) }.sort
end

#ordered_values(ordered_columns = ordered_keys) ⇒ Object 



34
35
36
37
38
 
# File 'lib/memory_tracker/gc_stat.rb', line 34

def ordered_values(ordered_columns = ordered_keys)
  ordered_columns.inject([]) do |vals, key|
    vals << @stats[current_version_key_name(key)]
  end
end