memory-profiler 1.0.3 → 1.1.0

metadata

@@ -1,58 +1,83 @@
 --- !ruby/object:Gem::Specification
 name: memory-profiler
 version: !ruby/object:Gem::Version
-  version: 1.0.3
+  version: 1.1.0
 platform: ruby
 authors:
-- Matthew Kerwin
-autorequire: 
+- Samuel Williams
 bindir: bin
-cert_chain: []
-date: 2014-04-18 00:00:00.000000000 Z
+cert_chain:
+- |
+  -----BEGIN CERTIFICATE-----
+  MIIE2DCCA0CgAwIBAgIBATANBgkqhkiG9w0BAQsFADBhMRgwFgYDVQQDDA9zYW11
+  ZWwud2lsbGlhbXMxHTAbBgoJkiaJk/IsZAEZFg1vcmlvbnRyYW5zZmVyMRIwEAYK
+  CZImiZPyLGQBGRYCY28xEjAQBgoJkiaJk/IsZAEZFgJuejAeFw0yMjA4MDYwNDUz
+  MjRaFw0zMjA4MDMwNDUzMjRaMGExGDAWBgNVBAMMD3NhbXVlbC53aWxsaWFtczEd
+  MBsGCgmSJomT8ixkARkWDW9yaW9udHJhbnNmZXIxEjAQBgoJkiaJk/IsZAEZFgJj
+  bzESMBAGCgmSJomT8ixkARkWAm56MIIBojANBgkqhkiG9w0BAQEFAAOCAY8AMIIB
+  igKCAYEAomvSopQXQ24+9DBB6I6jxRI2auu3VVb4nOjmmHq7XWM4u3HL+pni63X2
+  9qZdoq9xt7H+RPbwL28LDpDNflYQXoOhoVhQ37Pjn9YDjl8/4/9xa9+NUpl9XDIW
+  sGkaOY0eqsQm1pEWkHJr3zn/fxoKPZPfaJOglovdxf7dgsHz67Xgd/ka+Wo1YqoE
+  e5AUKRwUuvaUaumAKgPH+4E4oiLXI4T1Ff5Q7xxv6yXvHuYtlMHhYfgNn8iiW8WN
+  XibYXPNP7NtieSQqwR/xM6IRSoyXKuS+ZNGDPUUGk8RoiV/xvVN4LrVm9upSc0ss
+  RZ6qwOQmXCo/lLcDUxJAgG95cPw//sI00tZan75VgsGzSWAOdjQpFM0l4dxvKwHn
+  tUeT3ZsAgt0JnGqNm2Bkz81kG4A2hSyFZTFA8vZGhp+hz+8Q573tAR89y9YJBdYM
+  zp0FM4zwMNEUwgfRzv1tEVVUEXmoFCyhzonUUw4nE4CFu/sE3ffhjKcXcY//qiSW
+  xm4erY3XAgMBAAGjgZowgZcwCQYDVR0TBAIwADALBgNVHQ8EBAMCBLAwHQYDVR0O
+  BBYEFO9t7XWuFf2SKLmuijgqR4sGDlRsMC4GA1UdEQQnMCWBI3NhbXVlbC53aWxs
+  aWFtc0BvcmlvbnRyYW5zZmVyLmNvLm56MC4GA1UdEgQnMCWBI3NhbXVlbC53aWxs
+  aWFtc0BvcmlvbnRyYW5zZmVyLmNvLm56MA0GCSqGSIb3DQEBCwUAA4IBgQB5sxkE
+  cBsSYwK6fYpM+hA5B5yZY2+L0Z+27jF1pWGgbhPH8/FjjBLVn+VFok3CDpRqwXCl
+  xCO40JEkKdznNy2avOMra6PFiQyOE74kCtv7P+Fdc+FhgqI5lMon6tt9rNeXmnW/
+  c1NaMRdxy999hmRGzUSFjozcCwxpy/LwabxtdXwXgSay4mQ32EDjqR1TixS1+smp
+  8C/NCWgpIfzpHGJsjvmH2wAfKtTTqB9CVKLCWEnCHyCaRVuKkrKjqhYCdmMBqCws
+  JkxfQWC+jBVeG9ZtPhQgZpfhvh+6hMhraUYRQ6XGyvBqEUe+yo6DKIT3MtGE2+CP
+  eX9i9ZWBydWb8/rvmwmX2kkcBbX0hZS1rcR593hGc61JR6lvkGYQ2MYskBveyaxt
+  Q2K9NVun/S785AP05vKkXZEFYxqG6EW012U4oLcFl5MySFajYXRYbuUpH6AY+HP8
+  voD0MPg1DssDLKwXyt1eKD/+Fq0bFWhwVM/1XiAXL7lyYUyOq24KHgQ2Csg=
+  -----END CERTIFICATE-----
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies: []
-description: A rudimentary memory profiler that uses pure in-VM techniques to analyse
-  the object space and attempt to determine memory usage trends.
-email:
-- matthew@kerwin.net.au
 executables: []
-extensions: []
+extensions:
+- ext/extconf.rb
 extra_rdoc_files: []
 files:
-- lib/memory-profiler.rb
-- Gemfile
-- LICENSE
-- README
-- Rakefile
-- memory-profiler.gemspec
-homepage: https://github.com/phluid61/memory-profiler-gem
+- context/getting-started.md
+- context/index.yaml
+- ext/extconf.rb
+- ext/memory/profiler/capture.c
+- ext/memory/profiler/capture.h
+- ext/memory/profiler/profiler.c
+- lib/memory/profiler/call_tree.rb
+- lib/memory/profiler/capture.rb
+- lib/memory/profiler/sampler.rb
+- lib/memory/profiler/version.rb
+- lib/memory/tracker.rb
+- license.md
+- readme.md
+- releases.md
+homepage: https://github.com/socketry/memory-profiler
 licenses:
-- Apache License 2.0
-metadata: {}
-post_install_message: 
-rdoc_options:
-- --title
-- Memory Profiler
-- --main
-- MemoryProfiler
-- --line-numbers
-- --tab-width
-- '2'
+- MIT
+metadata:
+  documentation_uri: https://socketry.github.io/memory-profiler/
+  source_code_uri: https://github.com/socketry/memory-profiler
+rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '3.2'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.6
+      version: '0'
 requirements: []
-rubyforge_project: mem-prof-ruby
-rubygems_version: 2.0.3
-signing_key: 
+rubygems_version: 3.6.9
 specification_version: 4
-summary: A Ruby Memory Profiler
+summary: Efficient memory allocation tracking with call path analysis.
 test_files: []

data/Gemfile

@@ -1,11 +0,0 @@
-source 'https://rubygems.org'
-
-gemspec
-
-group :development do
-	gem 'rake'
-end
-
-group :test do
-	gem 'rake'
-end

data/LICENSE

@@ -1,13 +0,0 @@
-Copyright 2011 Matthew Kerwin
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASES,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.

data/README

@@ -1,71 +0,0 @@
-A rudimentary Ruby memory profiler that uses pure in-VM techniques to
-analyse the object space and attempt to determine memory usage trends.
-
-* Takes instantaneous snapshots, and can be used to determine trends
-  between subsequent instances.
-* Can also be used to detect memory leaks (obscure object references,
-  etc.) in particular blocks or sections of code.
-
-Note that this uses pure Ruby code and techniques, without patches to
-the VM. As such it is trivial to install and use, but it doesn't have
-access to raw memory management/garbage collection data, so is forced
-to estimate, and it will affect performance noticeably.
-
-It has been tested with the following Ruby versions (ruby -v):
-* ruby 1.8.7 (2009-06-12 patchlevel 174) [i486-linux]
-* ruby 1.9.1p243 (2009-07-16 revision 24175) [i486-linux]
-
-This project was inspired by the similar Ruby memory profiler at
-http://code.google.com/p/ruby-memory-profiler/ , which was apparently
-released under a BSD (or BSD-style) license; but since no attribution
-details were included, I haven't copied them here anywhere.
-
--------------------------------------------------------------------------
-
-The simplest way to use this utility is to copy the file:
-  lib/memory-profiler.rb
-to your project somewhere, and include it directly.
-
-However the correct way is to build the gem, so that you can use it in
-all your projects.
-
--------------------------------------------------------------------------
-
-To build the gem:
-
-  gem build memory-profiler.gemspec
-  gem install memory-profiler-1.0.2.gem
-
-Then in your code:
-
-  require 'rubygems' # Ruby 1.8 only
-  require 'memory-profiler'
-
--------------------------------------------------------------------------
-
-Refer to RDoc documentation for more detail, but here's an example for
-using the utility in your Ruby program:
-
-  # start the daemon, and let us know the file to which it reports
-  puts MemoryProfiler.start_daemon( :limit=>5, :delay=>10, :marshall_size=>true, :sort_by=>:absdelta )
-  
-  5.times do
-    blah = Hash.new([])
-    
-    # compare memory space before and after executing a block of code
-    rpt  = MemoryProfiler.start( :limit=>10 ) do
-      # some activities likely to create object references
-      100.times{ blah[1] << 'aaaaa' }
-      1000.times{ blah[2] << 'bbbbb' }
-    end
-    
-    # display the report in a (slightly) readable form
-    puts MemoryProfiler.format(rpt)
-    
-    sleep 7
-  end
-  
-  # terminate the daemon
-  MemoryProfiler.stop_daemon
-
--------------------------------------------------------------------------

data/Rakefile

@@ -1,7 +0,0 @@
-#!/usr/bin/env rake
-require 'bundler/gem_tasks'
-require 'rake/testtask'
-task :default => [:test]
-Rake::TestTask.new do |tt|
-	tt.verbose = true
-end

data/lib/memory-profiler.rb

@@ -1,338 +0,0 @@
-#!/usr/bin/ruby --
-# vim: tabstop=2:softtabstop=2:shiftwidth=2:noexpandtab
-=begin
-
-  Author:  Matthew Kerwin  <matthew@kerwin.net.au>
-  Version: 1.0.3
-  Date:    2014-04-19
-
-
-  Copyright 2011,2014 Matthew Kerwin.
-
-  Licensed under the Apache License, Version 2.0 (the "License");
-  you may not use this file except in compliance with the License.
-  You may obtain a copy of the License at
-
-      http://www.apache.org/licenses/LICENSE-2.0
-
-  Unless required by applicable law or agreed to in writing, software
-  distributed under the License is distributed on an "AS IS" BASIS,
-  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-  See the License for the specific language governing permissions and
-  limitations under the License.
-
-=end
-
-require 'sync'
-
-module MemoryProfiler
-	DEFAULTS = {
-		# general options
-		:sort_by  => :current,
-		:only     => [],
-		:ignore   => [],
-		:limit    => 20,
-		:force_gc => false,
-		# daemon options
-		:delay    => 60,
-		:filename => nil,
-		# ObjectSpaceAnalyser options
-		:string_debug  => false,
-		:marshal_size => false,
-	}
-	@@daemon_thread = nil    #:nodoc:
-	@@daemon_sync = Sync.new #:nodoc:
-
-	@@start_data = nil       #:nodoc:
-	@@start_sync = Sync.new  #:nodoc:
-
-	#
-	# Begins an analysis thread that runs periodically, reporting to a text
-	# file at:  /tmp/memory_profiler-<pid>.log
-	#
-	# Returns the filename used.
-	#
-	# Options:
-	#   :delay  => 60     # number of seconds between summaries
-	#   :filename => nil  # override the generated default
-	# See: #start for other options
-	#
-	def self.start_daemon(opt = {})
-		opt = DEFAULTS.merge(opt)
-		filename = opt[:filename] || "/tmp/memory_profiler-#{Process.pid}.log"
-		@@daemon_sync.synchronize(:EX) do
-			raise 'daemon process already running' if @@daemon_thread
-			@@daemon_thread = Thread.new do
-				prev = Hash.new(0)
-				file = File.open(filename, 'w')
-				loop do
-					begin
-						GC.start if opt[:force_gc]
-						curr = ObjectSpaceAnalyser.analyse(opt)
-						data = self._delta(curr, prev, opt)
-
-						file.puts '-'*80
-						file.puts Time.now.to_s
-						data.each {|k,c,d| file.printf( "%5d %+5d %s\n", c, d, k.name ) }
-
-						prev = curr
-						GC.start if opt[:force_gc]
-					rescue ::Exception => err
-						$stderr.puts "** MemoryProfiler daemon error: #{err}", err.backtrace.map{|b| "\t#{b}" }
-					end
-					sleep opt[:delay]
-				end #loop
-			end #Thread.new
-		end
-		filename
-	end
-
-	#
-	# Terminates the analysis thread started by #start_daemon
-	#
-	def self.stop_daemon
-		@@daemon_sync.synchronize(:EX) do
-			raise 'no daemon process running' unless @@daemon_thread
-			@@daemon_thread.kill
-			@@daemon_thread.join
-			@@daemon_thread = nil
-		end
-		self
-	end
-
-	#
-	# Generates an instantaneous report on the current Ruby ObjectSpace, saved to
-	# a text file at:  /tmp/memory_profiler-<pid>-<time>.log
-	#
-	# Returns the filename used.
-	#
-	# See: #start for valid/default options, except that :sort_by may
-	# only have the value :current or :none when using #report
-	#
-	def self.report(opt = {})
-		opt = DEFAULTS.merge(opt)
-		GC.start if opt[:force_gc]
-
-		data = ObjectSpaceAnalyser.analyse(opt)
-
-		if opt[:sort_by] == :current
-			data = data.to_a.sort_by{|k,v| -v }
-			data = data[0,opt[:limit]] if opt[:limit] > 0 and opt[:limit] < data.length
-		elsif opt[:sort_by] != :none
-			warn "MemoryProfiler: invalid option :sort_by => #{opt[:sort_by].inspect}; using :none"
-		end
-
-		filename = opt[:filename] || "/tmp/memory_profiler-#{Process.pid}-#{Time.now.to_i}.log"
-		File.open(filename, 'w') do |f|
-			data.each {|k,c| f.printf( "%5d %s\n", c, k.name ) }
-		end
-
-		GC.start if opt[:force_gc]
-		filename
-	end
-
-	#
-	# If a block is given, executes it and returns a summary.  Otherwise,
-	# starts the analyser, and waits for a call to #restart or #stop.
-	#
-	# Returned data is an array of:
-	#    [  [Class, current_usage, usage_delta],  ...  ]
-	#
-	# Options:
-	#   :sort_by       => :current  # how to order classes;  :current | :delta | :absdelta | :none
-	#   
-	#   :only          => []        # list of only classes to scan;  if empty, scans all classes
-	#   :ignore        => []        # list of classes to exclude from reports (including sub-classes and modules, but not namespaces)
-	#   :limit         => 20        # how many of the top classes to report (less than 1 means 'all'); only matters if :sort_by is not :none
-	#   
-	#   :force_gc      => true      # if true, forces a garbage collection before and after generating report
-	#   
-	#   :string_debug  => false     # see ObjectSpaceAnalyser#analyse
-	#   :marshal_size => false     # see ObjectSpaceAnalyser#analyse
-	#
-	def self.start(opt = {}, &block)
-		opt = DEFAULTS.merge(opt)
-		if block_given?
-			# get pre-block analysis of ObjectSpace
-			GC.start if opt[:force_gc]
-			prev = ObjectSpaceAnalyser.analyse(opt)
-			GC.start if opt[:force_gc]
-
-			yield
-
-			# get post-block analysis of ObjectSpace
-			GC.start if opt[:force_gc]
-			curr = ObjectSpaceAnalyser.analyse(opt)
-
-			# calculate the differences before and after execution
-			data = self._delta(curr, prev, opt)
-
-			# return it
-			GC.start if opt[:force_gc]
-			data
-		else
-			@@start_sync.synchronize(:EX) do
-				raise 'already started' if @@start_data
-
-				GC.start if opt[:force_gc]
-				@@start_data = [ObjectSpaceAnalyser.analyse(opt), opt]
-				GC.start if opt[:force_gc]
-			end
-			self
-		end
-	end
-
-	#
-	# Stops the current analysis and emits the results.
-	#
-	# See: #start
-	#
-	def self.stop
-		prev = nil
-		opt  = nil
-		@@start_sync.synchronize(:EX) do
-			raise 'not started' unless @@start_data
-			prev, opt = @@start_data
-			@@start_data = nil
-		end
-
-		# get the current state of affairs
-		GC.start if opt[:force_gc]
-		curr = ObjectSpaceAnalyser.analyse(opt)
-
-		# calculate the differences before and after execution
-		data = self._delta(curr, prev, opt)
-
-		# return it
-		GC.start if opt[:force_gc]
-		data
-	end
-
-	#
-	# Stops the current analysis, emits the results, and immediately starts
-	# a new analysis.
-	#
-	# See: #stop, #start
-	#
-	def self.restart(opt = {})
-		res = self.stop
-		self.start(opt)
-		res
-	end
-
-	# @private
-	#  => [ [Class, current, delta], ... ]
-	def self._delta(curr, prev, opt={}) #:nodoc:
-		opt = DEFAULTS.merge(opt)
-
-		# determine the difference between current and previous
-		delta = Hash.new(0)
-		(curr.keys + prev.keys).each do |k|
-			delta[k] = curr[k] - prev[k]
-		end
-		data = delta.map{|k,d| [k, curr[k].to_i, d]}
-
-		# organise data according to given options
-		case opt[:sort_by]
-		when :none
-			opt[:limit] = -1
-		when :current
-			data = data.sort_by{|k,c,d| -( c ) }
-		when :delta
-			data = data.sort_by{|k,c,d| -( d ) }
-		when :absdelta
-			data = data.sort_by{|k,c,d| -( d.abs ) }
-		else
-			warn "MemoryProfiler: invalid option :sort_by => #{opt[:sort_by].inspect}; using :none"
-			opt[:limit] = -1
-		end
-		data = data[0,opt[:limit]] if opt[:limit] > 0 and opt[:limit] < data.length
-
-		# return it
-		data
-	end
-
-	#
-	# Formats data, such as that returned by #start , into a printable,
-	# readable string.
-	#
-	def self.format(data)
-		" Curr. Delta Class\n" +
-		" ----- ----- -----\n" +
-		data.map{|k,c,d| sprintf(" %5d %+5d %s\n", c, d, k.name) }.join
-	end
-
-
-	module ObjectSpaceAnalyser
-		#
-		# Returns a hash mapping each Class to its usage.
-		#
-		# If opt[:marshal_size] is true, the usage is estimated using Marshal.dump() for each instance;
-		# otherwise it is a simple instance count.
-		#
-		# If opt[:string_debug] is true, the analyser writes a text file containing every string
-		# in the Ruby ObjectSpace, at:  /tmp/memory_profiler-<pid>-strings-<time>.log
-		#
-		# Uses opt[:only] and opt[:ignore] , as per MemoryProfiler#start
-		#
-		def self.analyse(opt = {})
-			opt = MemoryProfiler::DEFAULTS.merge(opt)
-			marshal_size = !!(opt[:marshal_size] || opt[:marshall_size])
-			string_debug = !!opt[:string_debug]
-			ign  = opt[:ignore]
-			only = opt[:only]
-
-			res = Hash.new(0)
-			str = [] if string_debug
-			ObjectSpace.each_object do |o|
-				if res[o.class] or ((only.empty? or only.any?{|y| o.is_a? y }) and ign.none?{|x| o.is_a? x })
-					res[o.class] += (marshal_size ? self.__sizeof(o) : 1)
-				end
-				str.push o.inspect if string_debug and o.class == String
-			end
-			if string_debug
-				self.__save str
-				str = nil
-			end
-			res
-		end
-
-		# Estimates the size of an object using Marshal.dump()
-		# Defaults to 1 if anything goes wrong.
-		def self.__sizeof(o) #:nodoc:
-			if o.respond_to? :dump
-				Marshal.dump(o).size
-			else
-				1
-			end
-		rescue ::Exception
-			1
-		end
-
-		# a single place where the magic filename is defined
-		def self.__save(str) #:nodoc:
-			File.open("/tmp/memory_profiler-#{Process.pid}-strings-#{Time.now.to_i}.log", 'w') do |f|
-				str.sort.each{|s| f.puts s }
-			end
-			str = nil
-		end
-	end
-end
-
-
-if $0 == __FILE__
-	puts MemoryProfiler.start_daemon( :limit=>5, :delay=>10, :marshal_size=>true, :sort_by=>:absdelta )
-
-	5.times do
-		blah = Hash.new([])
-		rpt  = MemoryProfiler.start( :limit=>10 ) do
-			100.times{ blah[1] << 'aaaaa' }
-			1000.times{ blah[2] << 'bbbbb' }
-		end
-		puts MemoryProfiler.format(rpt)
-		sleep 7
-	end
-
-	MemoryProfiler.stop_daemon
-end
-

data/memory-profiler.gemspec

@@ -1,27 +0,0 @@
-require 'rubygems'
-require 'rubygems/user_interaction' if RUBY_VERSION >= '1.9.1' and Gem::VERSION >= '1.4'
-require 'rake'
-
-Gem::Specification.new do |s|
-	s.name              = 'memory-profiler'
-	s.version           = '1.0.3'
-	s.platform          = Gem::Platform::RUBY
-	s.authors           = ['Matthew Kerwin']
-	s.email             = ['matthew@kerwin.net.au']
-	s.homepage          = 'https://github.com/phluid61/memory-profiler-gem'
-	s.summary           = 'A Ruby Memory Profiler'
-	s.description       = 'A rudimentary memory profiler that uses pure in-VM techniques to analyse the object space and attempt to determine memory usage trends.'
-	s.license           = 'Apache License 2.0'
-	s.rubyforge_project = 'mem-prof-ruby'
-
-	s.required_rubygems_version = '>= 1.3.6'
-
-	s.files            = Rake::FileList['lib/**/*.rb', '[A-Z]*'].to_a
-	s.require_path     = 'lib'
-
-	s.has_rdoc         = true
-	s.rdoc_options << '--title' << 'Memory Profiler' <<
-	                  '--main' << 'MemoryProfiler' <<
-	                  '--line-numbers' <<
-	                  '--tab-width' << '2'
-end