benelux 0.5.17 → 0.6.0

data/CHANGES.txt

@@ -1,8 +1,9 @@
 BENELUX, CHANGES
 
-#### 0.5.17 (2011-02-26) ##############################
 
-* FIXED: Fix for bug in Ruby 1.9.2 (same fix as in 0.6.1)
+#### 0.6.0 (2010-09-05) ##############################
+
+* CHANGE: Thread now belongs to Track (previously reversed)
 
 #### 0.5.16 (2010-06-08) ##############################
 

data/benelux.gemspec

@@ -1,7 +1,7 @@
 @spec = Gem::Specification.new do |s|
   s.name = "benelux"
   s.rubyforge_project = 'benelux'
-  s.version = "0.5.17"
+  s.version = "0.6.0"
   s.summary = "Benelux: A mad way to time Ruby codes"
   s.description = s.summary
   s.author = "Delano Mandelbaum"
@@ -13,7 +13,7 @@
   s.rdoc_options = ["--line-numbers", "--title", s.summary, "--main", "README.rdoc"]
   s.require_paths = %w[lib]
   
-  s.add_dependency("storable", [">= 0.6.5"])
+  s.add_dependency("storable", [">= 0.8.0"])
   
   # = MANIFEST =
   # git ls-files
@@ -35,16 +35,6 @@
   lib/selectable/global.rb
   lib/selectable/object.rb
   lib/selectable/tags.rb
-  tryouts/10_stats_tryouts.rb
-  tryouts/11_selectable_tryouts.rb
-  tryouts/20_tracks_tryouts.rb
-  tryouts/30_reporter_tryouts.rb
-  tryouts/30_timeline_tryouts.rb
-  tryouts/benelux_bm.rb
-  tryouts/proofs/alias_performance.rb
-  tryouts/proofs/array_performance.rb
-  tryouts/proofs/thread_array.rb
-  tryouts/proofs/timer_threading.rb
   )
 
   

data/lib/benelux.rb

@@ -5,7 +5,7 @@ require 'selectable'
 require 'storable'
 
 module Benelux
-  VERSION = "0.5.17"
+  VERSION = "0.6.0"
   NOTSUPPORTED = [Class, Object, Kernel]
   
   class BeneluxError < RuntimeError; end
@@ -66,15 +66,13 @@ module Benelux
   # If +track+ is nil, it returns the Track object for the
   # Track associated to the current thread. 
   #
-  def Benelux.current_track(name=nil,group=nil)
+  def Benelux.current_track(name=nil,timeline=nil)
     if name.nil?
       name = Thread.current.track_name
     else
       Thread.current.track_name = name
       @@mutex.synchronize do
-        Thread.current.timeline ||= Benelux::Timeline.new
-        Thread.current.rotated_timelines ||= []
-        @tracks[name] ||= Track.new(name, group)
+        @tracks[name] ||= Track.new(name, timeline || Thread.current.timeline || Benelux::Timeline.new)
         @tracks[name].add_thread Thread.current
         @known_threads << Thread.current
       end
@@ -83,6 +81,14 @@ module Benelux
   end
   Benelux.current_track :main
   
+  def Benelux.merge_tracks
+    tl = Benelux::Timeline.new
+    tracks.each_pair do |trackid,track|
+      tl.merge! track.timeline
+    end
+    tl
+  end
+  
   # Only updates data from threads that 
   # are dead and rotated timelines.
   def Benelux.update_global_timeline
@@ -115,18 +121,6 @@ module Benelux
     end
   end
   
-  # Thread tags become the default for any new Mark or Range. 
-  def Benelux.add_thread_tags(args=Selectable::Tags.new)
-    Benelux.thread_timeline.add_default_tags args
-  end
-  def Benelux.add_thread_tag(*args) add_thread_tags *args end
-  
-  def Benelux.remove_thread_tags(*args)
-    Benelux.thread_timeline.remove_default_tags *args
-  end
-  def Benelux.remove_thread_tag(*args) remove_thread_tags *args end
-  
-
   def Benelux.inspect
     str = ["Benelux"]
     str << "tracks:" << Benelux.tracks.inspect

data/lib/benelux/mixins.rb

@@ -23,9 +23,9 @@ end
 
 class Thread
   extend Attic
-  attr_accessor :timeline
-  attr_accessor :track_name
-  attr_accessor :rotated_timelines
+  attic :timeline
+  attic :track_name
+  attic :rotated_timelines
   def rotate_timeline
     self.rotated_timelines << self.timeline
     tags = self.timeline.default_tags.clone

data/lib/benelux/packer.rb

@@ -116,18 +116,21 @@ module Benelux
     def generate_packed_method
       %Q{
       def #{@meth}(*args, &block)
+        #p ["#{@meth} 1"]
         call_id = "" << self.object_id.abs.to_s << args.object_id.abs.to_s
         Benelux.current_track :global unless Benelux.known_thread?
-        mark_a = Benelux.thread_timeline.add_mark :'#{@aliaz}_a'
+        mark_a = Benelux.current_track.timeline.add_mark :'#{@aliaz}_a'
         mark_a.add_tag :call_id => call_id
         tags = mark_a.tags
         ret = #{@methorig}(*args, &block)
+        #p ["#{@meth} 2"]
+        ret
       rescue => ex  # We do this so we can use
         raise ex    # ex in the ensure block.
       ensure
-        mark_z = Benelux.thread_timeline.add_mark :'#{@aliaz}_z'
+        mark_z = Benelux.current_track.timeline.add_mark :'#{@aliaz}_z'
         mark_z.tags = tags # In case tags were added between these marks
-        range = Benelux.thread_timeline.add_range :'#{@aliaz}', mark_a, mark_z
+        range = Benelux.current_track.timeline.add_range :'#{@aliaz}', mark_a, mark_z
         range.exception = ex if defined?(ex) && !ex.nil?
       end
       }
@@ -149,7 +152,7 @@ module Benelux
         ret = #{@methorig}(*args, &block)
         count = cmd.determine_count(args, ret)
         #Benelux.ld "COUNT(:#{@meth}): \#{count}"
-        Benelux.thread_timeline.add_count :'#{@meth}', count
+        Benelux.current_track.timeline.add_count :'#{@meth}', count
         ret
       end
       }

data/lib/benelux/stats.rb

@@ -151,11 +151,11 @@ module Benelux
         @min, @max = 0.0, 0.0
       end
       
-      def samples(*args)
+      def samples(*args)  
         args.flatten.each { |s| sample(s) }
       end
       
-      def merge!(other)    
+      def merge!(other)
         return self if other.n == 0
         if @n == 0
           @min, @max = other.min, other.max

data/lib/benelux/track.rb

@@ -5,9 +5,11 @@ module Benelux
     attr_reader :name
     attr_reader :thread_group
     attr_reader :timeline
-    def initialize(n,g=nil)
-      @name, @thgrp = n, (g || ThreadGroup.new)
-      @timeline = Benelux::Timeline.new
+    attr_reader :rotated_timelines
+    def initialize(n,t)
+      @name, @thgrp = n, ThreadGroup.new
+      @timeline = t || Benelux::Timeline.new
+      @rotated_timelines = []
     end
     def add_thread(t=Thread.current)
       @thgrp.add t
@@ -16,5 +18,18 @@ module Benelux
     def threads
       @thgrp.list
     end
+    def add_tags(args=Selectable::Tags.new)
+      timeline.add_default_tags args
+    end
+    def remove_tags(*args)
+      timeline.remove_default_tags *args
+    end
+    ##def rotate_timeline
+    ##  self.rotated_timelines << self.timeline
+    ##  tags = self.timeline.default_tags.clone
+    ##  self.timeline = Benelux::Timeline.new
+    ##  self.timeline.default_tags = tags
+    ##  self.timeline
+    ##end
   end
 end

data/lib/selectable.rb

@@ -87,4 +87,8 @@ end
 
 class TaggableString < String
   include Selectable::Object
+  def initialize(str, tags={})
+    super(str)
+    add_tags tags unless tags.empty?
+  end
 end

data/lib/selectable/tags.rb

@@ -78,7 +78,7 @@ module Selectable
     end
     
     def method_missing(meth, *args)
-      raise SelectableError, "#{meth}: #{args.first} is not a Hash or Array"
+      raise SelectableError, "#{meth}: #{args.first} is not a Hash or Array #{self}"
     end
     
     ## NOTE: This is helpful but defensive. Ponder!

metadata

@@ -1,8 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: benelux
 version: !ruby/object:Gem::Version 
-  prerelease: 
-  version: 0.5.17
+  hash: 7
+  prerelease: false
+  segments: 
+  - 0
+  - 6
+  - 0
+  version: 0.6.0
 platform: ruby
 authors: 
 - Delano Mandelbaum
@@ -10,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-02-26 00:00:00 -05:00
+date: 2010-09-05 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -21,7 +26,12 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 0.6.5
+        hash: 63
+        segments: 
+        - 0
+        - 8
+        - 0
+        version: 0.8.0
   type: :runtime
   version_requirements: *id001
 description: "Benelux: A mad way to time Ruby codes"
@@ -52,16 +62,6 @@ files:
 - lib/selectable/global.rb
 - lib/selectable/object.rb
 - lib/selectable/tags.rb
-- tryouts/10_stats_tryouts.rb
-- tryouts/11_selectable_tryouts.rb
-- tryouts/20_tracks_tryouts.rb
-- tryouts/30_reporter_tryouts.rb
-- tryouts/30_timeline_tryouts.rb
-- tryouts/benelux_bm.rb
-- tryouts/proofs/alias_performance.rb
-- tryouts/proofs/array_performance.rb
-- tryouts/proofs/thread_array.rb
-- tryouts/proofs/timer_threading.rb
 has_rdoc: true
 homepage: http://github.com/delano/benelux
 licenses: []
@@ -80,17 +80,23 @@ required_ruby_version: !ruby/object:Gem::Requirement
   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: benelux
-rubygems_version: 1.5.2
+rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
 summary: "Benelux: A mad way to time Ruby codes"

data/tryouts/10_stats_tryouts.rb

@@ -1,66 +0,0 @@
-
-group "Benelux"
-
-library :benelux, 'lib'
-tryouts "Calculator" do
-  set :base, Benelux::Stats::Calculator.new
-  dream :class, Benelux::Stats::Calculator
-  dream :n, 10
-  dream :sum, 45
-  dream :sumsq, 285
-  dream :min, 0
-  dream :max, 9
-  dream :proc, lambda { |calc| calc.sd.to_i == 3 }
-  drill "can keep stats" do
-    10.times { |i| base.sample(i) }
-    base
-  end
-  
-  dream true
-  drill "can add stats" do
-    by_sample = Benelux::Stats::Calculator.new
-    10.times { |i| by_sample.sample(i) }
-    by_sample += base
-    by_merge = Benelux::Stats::Calculator.new
-    by_merge.merge! base
-    by_merge.merge! base
-    stash :sample, by_sample
-    stash :merge, by_merge
-    by_sample == by_merge
-  end
-  
-end
-
-tryouts "Stats" do
-  set :stat_names, [:execute, :request, :first_byte]
-  
-  dream stat_names
-  drill "knows stats names" do
-    stats = Benelux::Stats.new(stat_names)
-    stats.names
-  end
-  
-  drill "can keep multiple stats", true do
-    stats = Benelux::Stats.new(stat_names)
-    stats.execute.sample(rand)
-    stats.request.sample(rand*-1)
-    stats.execute != stats.request
-  end
-  
-  dream [true, true, true]
-  drill "can keep stats with tags" do
-    stats = Benelux::Stats.new(stat_names)
-    3.times { |i|
-      stats.execute.sample(rand, :usecase => '11')
-      stats.execute.sample(rand, :usecase => '11', :request => '22')
-      stats.execute.sample(rand, :request => '22')
-    }
-    stash :execute_stats, stats.execute
-    [
-      stats.execute['11'] == stats.execute[:usecase => '11'],
-      stats.execute['22'] == stats.execute[:request => '22'],
-      stats.execute['22','11'] == stats.execute[:usecase => '11', :request => '22']
-    ]
-  end
-  
-end

data/tryouts/11_selectable_tryouts.rb

@@ -1,92 +0,0 @@
-
-group "Benelux"
-
-library :benelux, 'lib'
-tryouts "Selectable" do
-  set :base, SelectableArray.new
-  
-  setup do
-    class ::TaggedItems
-      include Selectable::Object
-    end
-    10.times { |i|
-      obj = TaggedItems.new 
-      obj.add_tags :index => i, :even => (i%2 == 0)
-      base << obj
-    }
-  end
-  
-  dream :class, SelectableArray
-  dream :size, 5
-  drill "filter returns a new instance of the same object" do
-    base.filter(:even => true)
-  end
-  
-  dream :class, SelectableArray
-  dream :object_id, base.object_id
-  dream :size, 5
-  drill "filter! makes permanent changes to itself" do
-    base.filter! :even => true
-  end
-  
-end
-
-
-tryouts "Tags" do
-  set :base, Selectable::Tags[:a => 1, :b => 2]
-  
-  drill "Can equal a Hash with the same keys/values", true do
-    base == {:a => 1, :b => 2}
-  end
-  
-  drill "Implements a comparison operator", true do
-    base.respond_to? :'<=>'
-  end
-  
-  drill "Comparison operator returns 0 for same values", 0 do
-    base <=> {:a => 1, :b => 2}
-  end
-  
-  drill "Comparison operator returns 1 when it's a superset of other", 1 do
-    base <=> {:a => 1}
-  end
-
-  drill "Comparison operator returns -1 when it's a subset of other", -1 do
-    base <=> {:a => 1, :b => 2, :c => 3}
-  end
-  
-  drill "> returns false when compared to a hash with more key value pairs", false do
-    base > {:a => 1, :b => 2, :c => 3}
-  end
-  
-  drill "> returns true when compared to a hash with fewer key value pairs", true do
-    base > {:b => 2}
-  end
-  
-  drill "< returns true when compared to a hash with more key value pairs", true do
-    base < {:a => 1, :b => 2, :c => 3}
-  end
-  
-  drill "< returns false when compared to a hash with fewer key value pairs", false do
-    base < {:b => 2}
-  end
-  
-  drill "< returns false when compared to a hash with same values", false do
-    base < {:a => 1, :b => 2}
-  end
-
-  drill "<= returns true when compared to a hash with same values", true do
-    base <= {:b => 2, :a => 1}
-  end
-  
-  drill "< returns false when compared to an array with same values", false do
-    base < [1, 2]
-  end
-  
-  drill "<= returns true when compared to an array with same values", true do
-    base <= [2, 1]
-  end
-  
-end
-
-

data/tryouts/20_tracks_tryouts.rb

@@ -1,22 +0,0 @@
-group "Benelux"
-
-library :benelux, 'lib'
-tryouts "Tracks" do
-  
-  dream [:track1, :track1]
-  drill "Can specify current track" do
-    Benelux.current_track :track1
-    [Thread.current.track_name, Benelux.current_track.name]
-  end
-  
-  dream :class, Benelux::Timeline
-  drill "Track has a timeline" do
-    Benelux.current_track.timeline
-  end
-  
-  dream :exception, Benelux::UnknownTrack
-  drill "raises exception when unknown track specified" do
-    Benelux.track :name
-  end
-  
-end

data/tryouts/30_reporter_tryouts.rb

@@ -1,34 +0,0 @@
-group "Benelux"
-
-library :benelux, 'lib'
-xtryouts "Reporter" do
-  set :reporter, Benelux::Reporter.new
-  
-  drill "1", true do
-    p Benelux
-  end
-  
-  dream :exception, Benelux::BadRecursion
-  xdrill "will not report on itself" do
-    reporter.add_threads Thread.current
-  end
-  
-  dream :class, ThreadsWait
-  dream :empty?, false
-  xdrill "can add threads" do
-    2.times {
-      t = Thread.new do
-        3.times { sleep 1; }
-      end
-      reporter.add_thread t
-    }
-    reporter.thwait
-  end
-  
-  dream true
-  xdrill "will wait for known threads" do
-    reporter.start
-    reporter
-  end
-  
-end

data/tryouts/30_timeline_tryouts.rb

@@ -1,60 +0,0 @@
-
-
-__END__
-# OLD (0.3):
-
-group "Benelux"
-
-library :benelux, 'lib'
-tryouts "Timelines" do
-  set :tl, Benelux::Timeline.new
-  
-  setup do
-    class ::Sleeper
-      def   do_something()  sleep rand/3 end
-      def another_method(t) t*2          end 
-    end
-  end
-  
-  drill "Can set thread track", :track1 do
-    Benelux.current_track :track1
-#    Thread.current.track
-  end
-  
-  drill "Add timers to existing objects", true do
-    Benelux.add_timer Sleeper, :do_something
-    Sleeper.new.respond_to? :timeline
-  end
-  
-  dream :class, Benelux::Timeline
-  dream :size, 3
-  drill "create timeline with marks" do
-    tl.add_default_tags :a => :frog
-    tl.add_mark(:one)
-    tl.add_default_tags :b => :rest
-    tl.add_mark(:two)
-    tl.add_default_tags :c => :tilt
-    tl.add_mark(:three)
-    tl.marks
-  end
-  
-  dream :size, 2
-  drill "select marks based on tags" do
-    tl[:frog][:b => :rest]
-  end
-
-  dream :class, Benelux::Timeline
-  dream :size, 10 # 5 * 2 = 10
-  drill "Creates a timeline for the thread" do
-    sleeper = Sleeper.new
-    5.times { sleeper.do_something }
-    Benelux.thread_timeline
-  end
-  
-  dream :class, Benelux::Timeline
-  dream :size, 10
-  drill "Creates a global timeline" do
-    Benelux.update_all_track_timelines
-    Benelux.timeline
-  end
-end

data/tryouts/benelux_bm.rb

@@ -1,9 +0,0 @@
-# $ ruby -Ilib tryouts/benelux_bm.rb
-
-require 'benelux'
-
-a = Benelux.bm(1000000, 5) do
-  rand
-end
-
-p a 

data/tryouts/proofs/alias_performance.rb

@@ -1,33 +0,0 @@
-
-
-tryouts "Alias method speed", :benchmark do
-  set :runcount, 1_000
-  
-  setup do
-    module A;
-      extend self
-      def meth1; end
-      def meth2; end
-      alias_method :meth2_orig, :meth2
-      def meth2; end
-      def meth2_with_call; meth2_orig; end
-    end
-  end
-  
-  [10, 100].each do |mult|
-    count = runcount * mult
-    
-    drill "Natural method (#{count})", count do
-      A.meth1
-    end
-    
-    drill "Aliased method (#{count})", count do
-      A.meth2
-    end
-    
-    drill "Aliased method w/ call (#{count})", count do
-      A.meth2_with_call
-    end
-  end  
-  
-end

data/tryouts/proofs/array_performance.rb

@@ -1,57 +0,0 @@
-
-xtryouts "Array speed", :benchmark do
-  set :base, []
-  
-  drill "Populate array" do
-    10_000_000.times { base << 1 }
-  end
-  
-  drill "with <<" do
-    a = []
-    base.each { |v|
-      a << v
-    }
-    a.flatten!
-  end
-  
-  # SLOOOOOWWWWW (b/c it creates a new Array every iteration)
-  xdrill "with +=" do
-    a = []
-    base.each {|v|
-      a += [v]
-    }
-    a
-  end
-  
-  drill "with select" do
-    a = base.select { |v|
-      true
-    }
-    Array.new(a)
-  end
-  
-end
-
-
-tryouts "Array merge speed", :benchmark do
-  set :size, 10_000_000
-  set :merges, 100_000
-  
-  drill "Create #{size} element Array" do
-    final = []
-    size.times { final << 1 }
-  end
-  
-  drill "Merge #{size} element Array" do
-    all = []
-    msize = size / merges
-    merges.times do
-      a = []
-      msize.times { a << 1 }
-      all << a
-    end
-    final = []
-    all.each { |a| final.push *a }
-  end
-  
-end

data/tryouts/proofs/thread_array.rb

@@ -1,49 +0,0 @@
-
-
-require 'threadify'
-
-parallel = 20
-runcount = 100_000
-baseline = []
-testcase = []
-
-def timer(&blk)
-  s = Time.now; blk.call; puts ('%.4f' % (Time.now - s).to_f)
-end
-
-print "Populate baseline: "
-timer do 
-  parallel.times do
-    seed = "a"
-    (runcount).times do
-      baseline << seed.succ!.clone
-    end
-  end
-end
-
-print "Start #{parallel} threads: "
-threads = []
-timer do 
-  parallel.times do
-    threads << Thread.new do
-      seed = "a"
-      runcount.times { testcase << seed.succ!.clone }
-    end
-  end
-end
-
-print "Wait for threads: "
-timer do
-  threads.each { |t| t.join }
-end
-
-# Compare baseline to testcase
-p [:size,   testcase.size == baseline.size]
-p [:sorted, testcase.sort == baseline.sort]
-
-# Q: Why does the testcase Array seem to repeat perfectly?
-# [a,b,c,d,a,b,c,d,a,b,c,d]
-
-__END__
-
-Module.method_added?

data/tryouts/proofs/timer_threading.rb

@@ -1,30 +0,0 @@
-group "Benelux Concept Proofs"
-
-xtryouts "Time benchmarks", :benchmark do
-  set :runcount, 100000
-  
-  drill "Create Array", 1 do
-    @@timers = []
-  end
-  
-  drill "Time.now overhead", 5 do
-    runcount.times { Time.now.to_f }
-  end
-  
-  drill "[] << Time.now overhead", 5 do
-    runcount.times { @@timers << Time.now.to_f }
-  end
-  
-end
-
-require 'date'
-tryouts "Time proofs", :api do
-  set :runcount, 100000
-  
-  drill "All calls to Time.now.to_f are unique (will fail)", 0 do
-    timers = []
-    runcount.times { timers << Time.now.to_f; sleep 0.00000001 }
-    timers.size - timers.uniq.size
-  end
-  
-end