whysoslow 0.0.1

data/.gitignore

@@ -0,0 +1,6 @@
+pkg/*
+.bundle
+*.gem
+*.log
+.rvmrc
+.rbenv-version

data/Gemfile

@@ -0,0 +1,6 @@
+source "http://rubygems.org"
+
+# Specify dependencies in whysoslow.gemspec
+gemspec
+
+gem 'rake', '~>0.9.2'

data/Gemfile.lock

@@ -0,0 +1,25 @@
+PATH
+  remote: .
+  specs:
+    whysoslow (0.0.1)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    ansi (1.4.2)
+    assert (0.7.3)
+      assert-view (~> 0.5)
+    assert-view (0.5.0)
+      ansi (~> 1.3)
+      undies (~> 2.0)
+    rake (0.9.2.2)
+    undies (2.2.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  assert
+  bundler
+  rake (~> 0.9.2)
+  whysoslow!

data/README.rdoc

@@ -0,0 +1,59 @@
+= Whysoslow
+
+== Description
+
+Whysoslow is a little runner/printer I wrote to benchmark my Ruby code.  It runs a block of code, collects run time measurements, and can snapshot memory usage information at various points during execution.
+
+It has no tests, shockingly sparse docs, and is more of an experiment at this point.  It comes as is for now so use if you see fit.
+
+I will happily accept any pull requests for documentation, tests, extensions, and improvements.
+
+== Installation
+
+    gem install whysoslow
+
+== Usage
+
+    require 'whysoslow'
+
+    printer = Whysoslow::DefaultPrinter.new({
+      :title => "Bench Report Title",
+      :verbose => true
+    })
+
+    runner = Whysoslow::Runner.new(@printer)
+
+    runner.run do
+      # ... some long running script or loop
+      runner.snapshot("mem usage during run")
+      # ... some more long running script or loop
+    end
+
+== Output: DefaultPrinter
+
+The DefaultPrinter outputs to an io stream ($stdout by default).  It uses Ansi to output columned memory usage snapshot data and measurement data.
+
+== License
+
+Copyright (c) 2012 Kelly Redding
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,7 @@
+require 'assert/rake_tasks'
+Assert::RakeTasks.for(:test)
+
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+task :default => :build

data/lib/whysoslow.rb

@@ -0,0 +1,4 @@
+module Whysoslow; end
+
+require 'whysoslow/runner'
+require 'whysoslow/default_printer'

data/lib/whysoslow/default_printer.rb

@@ -0,0 +1,91 @@
+require 'ansi'
+
+module Whysoslow
+  class DefaultPrinter
+
+    def initialize(*args)
+      @opts, @ios = [
+        args.last.kind_of?(::Hash) ? args.pop : {},
+        args.pop || $stdout
+      ]
+      @ios.sync = true
+      @title = @opts[:title]
+      @verbose = @opts[:verbose]
+    end
+
+    def print(thing)
+      case thing
+      when :title
+        if @title
+          @ios.puts @title.to_s
+          @ios.puts '-'*(@title.to_s.length)
+        end
+      when :run_start
+        @ios.print "whysoslow? " if @verbose
+      when :snapshot
+        @ios.print '.' if @verbose
+      when :run_end
+        @ios.print "\n\n" if @verbose
+      when Whysoslow::Results
+        @ios << snapshots_table(thing)
+        @ios.puts
+        @ios << measurements_table(thing)
+      else
+      end
+    end
+
+    protected
+
+    def snapshots_table(results)
+      units = results.snapshot_units
+      tdata = [
+        results.snapshot_labels.collect { |l| "mem @ #{l}" },
+        results.snapshot_usages.collect { |u| "#{memory_s(u)} #{units}" },
+        results.snapshot_diffs.collect do |diff_perc|
+          diff = diff_perc.first
+          perc = diff_perc.last
+          if diff == '??'
+            "??"
+          elsif diff > 0
+            ANSI.red do
+              "+#{memory_s(diff.abs)} #{units}, #{perc_s(perc)}%"
+            end
+          else
+            ANSI.green do
+              "-#{memory_s(diff.abs)} #{units}, #{perc_s(perc)}%"
+            end
+          end
+        end
+      ].flatten
+      ANSI::Columns.new(tdata, {
+        :columns => 3,
+        :align => :left,
+        :padding => 1
+      }).to_s
+    end
+
+    def measurements_table(results)
+      units = results.measurement_units
+      tdata = [
+        ['', 'time'],
+        results.measurements.collect do |l_t|
+          [l_t.first, "#{l_t.last} #{units}"]
+        end
+      ].flatten
+      ANSI::Columns.new(tdata, :columns => 5, :align=>:left).to_s
+    end
+
+    def snapshots_label_col
+      results.snapshots.collect{|r| "mem @ #{r.label}" }
+    end
+
+    def memory_s(amount)
+      amount.round.to_s.rjust(4)
+    end
+
+    def perc_s(perc)
+      (perc*100).round.abs.to_s.rjust(3)
+    end
+
+  end
+end

data/lib/whysoslow/measurement.rb

@@ -0,0 +1,34 @@
+require 'benchmark'
+
+module Whysoslow
+  class Measurement
+
+    MEASUREMENTS = [:user, :system, :total, :real]
+    attr_reader :units, :multiplier
+    attr_reader *MEASUREMENTS
+
+    def initialize(units='ms')
+      @user, @system, @total, @real = 0
+      @units, @multiplier = if units == 's'
+        ['s', 1]
+      else # MB
+        ['ms', 1000]
+      end
+    end
+
+    def benchmark(&block)
+      Benchmark.measure(&block).tap do |values|
+        measurments = values.to_s.strip.gsub(/[^\s|0-9|\.]/, '').split(/\s+/)
+        self.user, self.system, self.total, self.real = measurments
+      end
+    end
+
+    protected
+
+    def user=(value_in_secs);   @user   = value_in_secs.to_f * @multiplier; end
+    def system=(value_in_secs); @system = value_in_secs.to_f * @multiplier; end
+    def total=(value_in_secs);  @total  = value_in_secs.to_f * @multiplier; end
+    def real=(value_in_secs);   @real   = value_in_secs.to_f * @multiplier; end
+
+  end
+end

data/lib/whysoslow/memory_profile.rb

@@ -0,0 +1,46 @@
+module Whysoslow
+
+  class MemoryProfile
+
+    class Snapshot; end
+
+    attr_reader :snapshots, :divider
+    attr_accessor :units
+
+    def initialize(units='MB')
+      @snapshots = []
+      self.units = units
+    end
+
+    def units=(value)
+      @units, @divider = if value == 'KB'
+        ['KB', 1]
+      else # MB
+        ['MB', 1000]
+      end
+    end
+
+    def snapshot(label)
+      Snapshot.new(label, @divider).tap { |snap| @snapshots.push(snap) }
+    end
+
+  end
+
+  class MemoryProfile::Snapshot
+
+    attr_reader :label, :memory
+
+    def initialize(label, divider)
+      @label = label
+      @memory = capture_memory_usage(divider)
+    end
+
+    protected
+
+    def capture_memory_usage(divider)
+      ((`ps -o rss= -p #{$$}`.to_i) / divider.to_f)
+    end
+
+  end
+
+end

data/lib/whysoslow/results.rb

@@ -0,0 +1,67 @@
+require 'whysoslow/measurement'
+require 'whysoslow/memory_profile'
+
+module Whysoslow
+  class Results
+
+    attr_reader :desc
+
+    def initialize(desc, time_unit, memory_unit)
+      @desc = desc
+      @measurement = Measurement.new(time_unit)
+      @memory_profile = MemoryProfile.new(memory_unit)
+    end
+
+    def benchmark(*args, &block)
+      @measurement.benchmark(*args, &block)
+    end
+
+    def snapshot(*args)
+      @memory_profile.snapshot(*args)
+    end
+
+    def snapshots
+      @snapshots ||= @memory_profile.snapshots
+    end
+
+    def snapshot_units
+      @memory_profile.units
+    end
+
+    def snapshot_labels
+      snapshots.collect{|s| s.label }
+    end
+
+    def snapshot_usages
+      snapshots.collect{|s| s.memory }
+    end
+
+    def snapshot_diffs
+      prev = nil
+      snapshots.inject([]) do |diffs, snapshot|
+        if prev.nil? || prev.memory == 0
+          diffs << ['??', '??']
+        else
+          diff = snapshot.memory - prev.memory
+          diffs << [
+            diff,
+            diff.to_f / prev.memory.to_f
+          ]
+        end
+        prev = snapshot
+        diffs
+      end
+    end
+
+    def measurements
+      @measurements ||= Measurement::MEASUREMENTS.collect do |m|
+        [m, @measurement.send(m)]
+      end
+    end
+
+    def measurement_units
+      @measurement.units
+    end
+
+  end
+end

data/lib/whysoslow/runner.rb

@@ -0,0 +1,37 @@
+require 'whysoslow/results'
+
+module Whysoslow
+
+  class Runner
+
+    attr_accessor :desc, :verbose, :time_unit, :memory_unit
+
+    def initialize(printer, opts={})
+      @printer = printer
+      @time_unit = opts[:time_unit]
+      @memory_unit = opts[:memory_unit]
+      @results = nil
+    end
+
+    def run(&block)
+      @printer.print :title
+      @printer.print(Results.new(@desc, @time_unit, @memory_unit).tap do |results|
+        @results = results
+        @printer.print :run_start
+        self.snapshot('start')
+        @results.benchmark(&block)
+        self.snapshot('finish')
+        @printer.print :run_end
+        @results = nil
+      end)
+    end
+
+    def snapshot(*args)
+      raise RuntimeError, "no active results being gathered - be sure and call snapshot during a run session" if @results.nil?
+      @results.snapshot(*args)
+      @printer.print :snapshot
+    end
+
+  end
+end
+

data/lib/whysoslow/version.rb

@@ -0,0 +1,3 @@
+module Whysoslow
+  VERSION = "0.0.1"
+end

data/test/helper.rb

@@ -0,0 +1,5 @@
+# this file is automatically required in when you require 'assert' in your tests
+# put test helpers here
+
+# add root dir to the load path
+$LOAD_PATH.unshift(File.expand_path("../..", __FILE__))

data/test/irb.rb

@@ -0,0 +1,9 @@
+require 'assert/setup'
+
+# this file is required in when the 'irb' rake test is run.
+# b/c 'assert/setup' is required above, the test helper will be
+# required in as well.
+
+# put any IRB setup code here
+
+require 'whysoslow'

data/test/whysoslow_test.rb

@@ -0,0 +1,4 @@
+require "assert"
+
+class WhysoslowTest < Assert::Context
+end

data/whysoslow.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "whysoslow/version"
+
+Gem::Specification.new do |s|
+  s.name        = "whysoslow"
+  s.version     = Whysoslow::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Kelly Redding"]
+  s.email       = ["kelly@kellyredding.com"]
+  s.homepage    = "http://github.com/kellyredding/whysoslow"
+  s.summary     = %q{A little runner/printer to benchmark Ruby code blocks}
+  s.description = %q{A little runner/printer to benchmark Ruby code blocks}
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_development_dependency("bundler")
+  s.add_development_dependency("assert")
+end

metadata

@@ -0,0 +1,110 @@
+--- !ruby/object:Gem::Specification 
+name: whysoslow
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Kelly Redding
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-02-20 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  type: :development
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  version_requirements: *id001
+  name: bundler
+- !ruby/object:Gem::Dependency 
+  type: :development
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  version_requirements: *id002
+  name: assert
+description: A little runner/printer to benchmark Ruby code blocks
+email: 
+- kelly@kellyredding.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- Gemfile.lock
+- README.rdoc
+- Rakefile
+- lib/whysoslow.rb
+- lib/whysoslow/default_printer.rb
+- lib/whysoslow/measurement.rb
+- lib/whysoslow/memory_profile.rb
+- lib/whysoslow/results.rb
+- lib/whysoslow/runner.rb
+- lib/whysoslow/version.rb
+- test/helper.rb
+- test/irb.rb
+- test/whysoslow_test.rb
+- whysoslow.gemspec
+homepage: http://github.com/kellyredding/whysoslow
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.11
+signing_key: 
+specification_version: 3
+summary: A little runner/printer to benchmark Ruby code blocks
+test_files: 
+- test/helper.rb
+- test/irb.rb
+- test/whysoslow_test.rb