Class: Memory::Sampler

Inherits:
Object
  • Object
show all
Defined in:
lib/memory/sampler.rb

Overview

Sample memory allocations.

~~~ ruby sampler = Sampler.capture do 5.times { “foo” } end ~~~

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(&filter) ⇒ Sampler

Returns a new instance of Sampler.



69
70
71
72
73
74
75
 
# File 'lib/memory/sampler.rb', line 69

def initialize(&filter)
	@filter = filter
	
	@cache = Cache.new
	@wrapper = Wrapper.new(@cache)
	@allocated = Array.new
end

Instance Attribute Details

#allocated ⇒ Object (readonly)

Returns the value of attribute allocated.



81
82
83
 
# File 'lib/memory/sampler.rb', line 81

def allocated
  @allocated
end

#cache ⇒ Object (readonly)

Returns the value of attribute cache.



79
80
81
 
# File 'lib/memory/sampler.rb', line 79

def cache
  @cache
end

#filter ⇒ Object (readonly)

Returns the value of attribute filter.



77
78
79
 
# File 'lib/memory/sampler.rb', line 77

def filter
  @filter
end

#wrapper ⇒ Object (readonly)

Returns the value of attribute wrapper.



80
81
82
 
# File 'lib/memory/sampler.rb', line 80

def wrapper
  @wrapper
end

Instance Method Details

#dump(io = nil) ⇒ Object 



111
112
113
114
115
116
117
118
119
120
121
 
# File 'lib/memory/sampler.rb', line 111

def dump(io = nil)
	Console.logger.debug(self, "Dumping allocations: #{@allocated.size}")
	
	if io
		packer = @wrapper.packer(io)
		packer.pack(@allocated)
		packer.flush
	else
		@wrapper.dump(@allocated)
	end
end

#load(data) ⇒ Object 



123
124
125
126
127
128
129
 
# File 'lib/memory/sampler.rb', line 123

def load(data)
	allocations = @wrapper.load(data)
	
	Console.logger.debug(self, "Loading allocations: #{allocations.size}")
	
	@allocated.concat(allocations)
end

#report ⇒ Object 



131
132
133
134
135
136
137
 
# File 'lib/memory/sampler.rb', line 131

def report
	report = Report.general
	
	report.concat(@allocated)
	
	return report
end

#run(&block) ⇒ Object

Collects object allocation and memory of ruby code inside of passed block.



140
141
142
143
144
145
146
147
148
149
 
# File 'lib/memory/sampler.rb', line 140

def run(&block)
	start
	
	begin
		# We do this to avoid retaining the result of the block.
		yield && false
	ensure
		stop
	end
end

#start ⇒ Object 



83
84
85
86
87
88
89
 
# File 'lib/memory/sampler.rb', line 83

def start
	GC.disable
	GC.start
	
	@generation = GC.count
	ObjectSpace.trace_object_allocations_start
end

#stop ⇒ Object 



91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
 
# File 'lib/memory/sampler.rb', line 91

def stop
	ObjectSpace.trace_object_allocations_stop
	allocated = track_allocations(@generation)
	
	# **WARNING** Do not allocate any new Objects between the call to GC.start and the completion of the retained lookups. It is likely that a new Object would reuse an object_id from a GC'd object.
	
	GC.enable
	3.times{GC.start}
	
	ObjectSpace.each_object do |object|
		next unless ObjectSpace.allocation_generation(object) == @generation
		
		if found = allocated[object.__id__]
			found.retained = true
		end
	end
	
	ObjectSpace.trace_object_allocations_clear
end