benelux 0.3.2 → 0.4.1

data/CHANGES.txt

@@ -1,6 +1,21 @@
 BENELUX, CHANGES
 
 
+#### 0.4.1 (2009-10-06) ###############################
+
+* FIXED: Nil @thread error in reporter
+* CHANGE: Reporter starts only one thread.
+
+
+#### 0.4.0 (2009-10-05) ###############################
+
+* CHANGE: All tag values are stored as strings. Keys can be anything.
+* CHANGE: Removed object-specific timelines
+* CHANGED: Stats calculators no longer keep all values
+* ADDED: Counts
+* ADDED: Reporter thread
+
+
 #### 0.3.2 (2009-10-02) ###############################
 
 * CHANGE: Major performance improvement.

data/README.rdoc

@@ -1,4 +1,4 @@
-= Benelux v0.3 (IN PROGRESS)
+= Benelux v0.4 (IN PROGRESS)
 
 <b>A madhouse of timers for your Ruby codes</b>
 

data/benelux.gemspec

@@ -1,7 +1,7 @@
 @spec = Gem::Specification.new do |s|
   s.name = "benelux"
   s.rubyforge_project = 'benelux'
-  s.version = "0.3.2"
+  s.version = "0.4.1"
   s.summary = "Benelux: Little freakin' timers for your Ruby codes"
   s.description = s.summary
   s.author = "Delano Mandelbaum"
@@ -24,17 +24,28 @@
   Rakefile
   benelux.gemspec
   lib/benelux.rb
+  lib/benelux/count.rb
   lib/benelux/mark.rb
+  lib/benelux/mixins/symbol.rb
   lib/benelux/mixins/thread.rb
+  lib/benelux/packer.rb
   lib/benelux/range.rb
+  lib/benelux/reporter.rb
   lib/benelux/stats.rb
-  lib/benelux/tags.rb
   lib/benelux/timeline.rb
+  lib/benelux/track.rb
+  lib/selectable.rb
+  lib/selectable/global.rb
+  lib/selectable/object.rb
+  lib/selectable/tags.rb
   tryouts/10_stats_tryouts.rb
-  tryouts/11_tags_tryouts.rb
-  tryouts/20_class_methods_tryouts.rb
+  tryouts/11_selectable_tryouts.rb
+  tryouts/12_selectable_global_tryouts.rb
+  tryouts/20_tracks_tryouts.rb
+  tryouts/30_reporter_tryouts.rb
   tryouts/30_timeline_tryouts.rb
   tryouts/proofs/alias_performance.rb
+  tryouts/proofs/array_performance.rb
   tryouts/proofs/timer_threading.rb
   )
 

data/lib/benelux.rb

@@ -1,246 +1,215 @@
 require 'attic'
 require 'hexoid'
 require 'thread'
+require 'thwait'
+require 'selectable'
 
 module Benelux
-  VERSION = "0.3.2"
+  VERSION = "0.4.1"
   NOTSUPPORTED = [Class, Object, Kernel]
   
   class BeneluxError < RuntimeError; end
   class NotSupported < BeneluxError; end
-  class NoTrack < BeneluxError; end
+  class AlreadyTimed < BeneluxError; end
+  class UnknownTrack < BeneluxError; end
+  class BadRecursion < BeneluxError; end
   
-  require 'benelux/tags'
   require 'benelux/mark'
+  require 'benelux/count'
+  require 'benelux/track'
   require 'benelux/range'
   require 'benelux/stats'
+  require 'benelux/packer'
+  require 'benelux/reporter'
   require 'benelux/timeline'
   require 'benelux/mixins/thread'
+  require 'benelux/mixins/symbol'
   
-  @@timed_methods = {}
-  @@known_threads = []
-  @@timelines = {}
-  @@mutex = Mutex.new
-  @@debug = true
+  class << self
+    attr_reader :packed_methods
+    attr_reader :tracks
+    attr_reader :timeline
+    attr_reader :reporter
+  end
   
-  def Benelux.enable_debug; @@debug = true; end
-  def Benelux.disable_debug; @@debug = false; end
-  def Benelux.debug?; @@debug; end
+  @packed_methods = SelectableArray.new
+  @tracks = SelectableHash.new
+  @timeline = Timeline.new
+  @reporter = Reporter.new
   
-  # Returns an Array of method names for the current class that
-  # are timed by Benelux. 
-  #
-  # This is an instance method for objects which have Benelux 
-  # modified methods. 
-  def benelux_timers
-    Benelux.timed_methods[self.class]
-  end
+  @@mutex = Mutex.new
+  @@debug = false
+  @@logger = STDERR
   
-  def Benelux.timeline(track=nil)
-    if track.nil?
-      if Benelux.timelines.empty?
-        tl = known_threads.collect { |t| t.timeline}
-      else
-        tl = Benelux.timelines.values
-      end
-      Benelux.merge_timelines *tl
-    else
-      Benelux.timelines[track]
-    end
+  def Benelux.thread_timeline
+    Thread.current.timeline
   end
   
-  # Must be run in single-threaded mode (after all track threads
-  # have finished).
-  #
-  def Benelux.update_all_track_timelines
-    Benelux.timelines.keys.each { |track| Benelux.update_track_timeline(track) }
+  def Benelux.track(name)
+    raise UnknownTrack unless track? name
+    @tracks[name]
   end
   
-  # Must be run from the master thread in the current track. The master
-  # thread is either the first thread in a track or the one which creates
-  # additional threads for the track. 
-  #
-  def Benelux.update_track_timeline(track=nil)
-    track = Thread.current.track if track.nil?
-    threads = Benelux.known_threads.select { |t| t.track == track }
-    Benelux.timelines[track] = Benelux.merge_timelines(*threads.collect { |t| t.timeline })
-    threads.each { |t| t.timeline.clear }
-    Benelux.timelines[track]
+  def Benelux.track?(name)
+    @tracks.has_key? name
   end
   
-  # If +track+ is specified, this will associate the current
-  # thread with that +track+. 
+  # If +name+ is specified, this will associate the current
+  # thread with that Track +name+ (the Track will be created
+  # if necessary).
   #
-  # If +track+ is nil, it returns the timeline for the
-  # track associated to the current thread. 
+  # If +track+ is nil, it returns the Track object for the
+  # Track associated to the current thread. 
   #
-  def Benelux.current_track(track=nil)
-    if track.nil? 
-      raise NoTrack if Benelux.timelines[Thread.current.track].nil?
-      return Benelux.timelines[Thread.current.track] 
-    end
-    Benelux.store_thread_reference
-    @@mutex.synchronize do
-      # QUESTION: Is it okay for multiple threads to write to
-      # different elements in the same hash?
-      Benelux.timelines[track] ||= Benelux::Timeline.new
-      Benelux.add_thread_tags :track => track
-      Thread.current.track = track
+  def Benelux.current_track(name=nil,group=nil)
+    if name.nil?
+      name = Thread.current.track_name
+    else
+      Thread.current.track_name = name
+      Thread.current.timeline ||= Benelux::Timeline.new
+      @@mutex.synchronize do
+        @tracks[name] ||= Track.new(name, group)
+        @tracks[name].add_thread Thread.current
+        @reporter.add_thread Thread.current
+      end
     end
+    Benelux.track(name)
   end
+  Benelux.current_track :main
   
-  # Combine two or more timelines into a new, single Benelux::Timeline.
-  #
-  def Benelux.merge_timelines(*timelines)
-    tl, stats, ranges = Benelux::Timeline.new, Benelux::Stats.new, []
-    timelines.each do |t|
-      tl += t
-    end
-    tl
+  # 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.thread_timeline
-    Thread.current.timeline ||= Benelux::Timeline.new
-    Thread.current.timeline
+  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
   
-  # Make note of the class which included Benelux. 
-  def Benelux.included(klass)
-    timed_methods[klass] = [] unless timed_methods.has_key? klass
+
+  def Benelux.inspect
+    str = ["Benelux"]
+    str << "tracks:" << Benelux.tracks.inspect
+    str << "timers:" << Benelux.timed_methods.inspect
+    #str << "timeline:" << Benelux.timeline.inspect
+    str.join $/
   end
   
-  def Benelux.timed_method? klass, meth
-    !timed_methods[klass].nil? && timed_methods[klass].member?(meth)
+  def Benelux.supported?(klass)
+    !NOTSUPPORTED.member?(klass)
   end
   
-  def Benelux.add_timer klass, meth
-    raise NotSupported, klass unless Benelux.supported? klass
-    raise AlreadyTimed, klass if Benelux.timed_method? klass, meth
-    prepare_object klass
-    meth_alias = rename_method klass, meth
-    timed_methods[klass] << meth
-    klass.module_eval generate_timer_str(meth_alias, meth), __FILE__, 215
+  def Benelux.timed_methods
+    Benelux.packed_methods.filter :kind => :'Benelux::MethodTimer'
+  end
+
+  def Benelux.counted_methods
+    Benelux.packed_methods.filter :kind => :'Benelux::MethodCounter'
   end
   
-  def Benelux.add_tally obj, meth
+  def Benelux.known_thread?(t=Thread.current)
+    @reporter.thwait.threads.member? t
   end
   
-  def Benelux.name(*names)
-    names.flatten.collect { |n| n.to_s }.join('_')
+  def Benelux.known_threads
+    @reporter.thwait.threads
   end
   
+  def Benelux.reporting_wait
+    @reporter.wait
+  end
   
-  def Benelux.prepare_object obj
-    obj.extend Attic  unless obj.kind_of?(Attic)
-    unless obj.kind_of?(Benelux)
-      obj.attic :timeline
-      obj.send :include, Benelux
-    end
+  def Benelux.packed_method(klass, meth)
+    Benelux.packed_methods.filter(klass.to_s.to_sym, meth).first
   end
-
-  # Benelux keeps track of the threads which have timed
-  # objects so it can process the timelines after all is
-  # said and done. 
-  def Benelux.store_thread_reference
-    return if Benelux.known_threads.member? Thread.current
-    @@mutex.synchronize do
-      Thread.current.timeline ||= Benelux::Timeline.new
-      Benelux.known_threads << Thread.current
-      Benelux.known_threads.uniq!
-    end
+  
+  def Benelux.counted_method(klass, meth)
+    Benelux.counted_methods.filter(klass.to_s.to_sym, meth).first
   end
   
-  # Thread tags become the default for any new Mark or Range. 
-  def Benelux.add_thread_tags(args=Benelux::Tags.new)
-    Benelux.thread_timeline.add_default_tags args
+  def Benelux.timed_method(klass, meth)
+    Benelux.timed_methods.filter(klass.to_s.to_sym, meth).first
   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
+  def Benelux.timed_method? klass, meth
+    Benelux.packed_method? klass, meth, :'Benelux::MethodTimer'
   end
-  def Benelux.remove_thread_tag(*args) remove_thread_tags *args end
   
-  def Benelux.tracks
-    Benelux.timelines.keys
+  def Benelux.counted_method? klass, meth
+    Benelux.packed_method? klass, meth, :'Benelux::MethodCounter'
   end
   
-  def Benelux.inspect
-    str = ["Benelux"]
-    str << "threads:" << Benelux.known_threads.inspect
-    str << "tracks:" << Benelux.tracks.inspect
-    str << "timers:" << Benelux.timed_methods.inspect
-    str << "timeline:" << Benelux.timeline.inspect
-    str.join $/
+  def Benelux.packed_method? klass, meth, kind=nil
+    list = Benelux.packed_methods.filter(klass.to_s.to_sym, meth)
+    list.filter! :kind => kind unless kind.nil?
+    !list.empty?
   end
   
-  def Benelux.supported?(klass)
-    !NOTSUPPORTED.member?(klass)
+  
+  def Benelux.add_timer klass, meth, &blk
+    raise NotSupported, klass unless Benelux.supported? klass
+    raise AlreadyTimed, klass if Benelux.timed_method? klass, meth
+    Benelux::MethodTimer.new klass, meth, &blk
   end
   
-  def Benelux.timed_methods
-    @@timed_methods
+  def Benelux.add_counter klass, meth, &blk
+    raise NotSupported, klass unless Benelux.supported? klass
+    Benelux::MethodCounter.new klass, meth, &blk
   end
   
-  def Benelux.known_threads
-    @@known_threads
+  def Benelux.ld(*msg)
+    @@logger.puts "D:  " << msg.join("#{$/}D:  ") if debug?
   end
   
-  def Benelux.timelines
-    @@timelines
+  
+  # Returns an Array of method names for the current class that
+  # are timed by Benelux. 
+  #
+  # This is an instance method for objects which have Benelux 
+  # modified methods. 
+  def timed_methods
+    Benelux.timed_methods.filter(:class => self.class.to_s.to_sym)
   end
   
-  # Rename the method +meth+ in the object +obj+ and return
-  # the new alias. 
-  # 
-  # e.g.
+  # Returns an Array of method names for the current class that
+  # are counted by Benelux. 
   #
-  #     Benelux.renamed(SomeClass, :execute) 
-  #       # => __benelux_execute_2151884308_2165479316
-  # 
-  def Benelux.rename_method(obj, meth)
-    ## NOTE: This is commented out so we can include  
-    ## Benelux definitions before all classes are loaded. 
-    ##unless obj.respond_to? meth
-    ##  raise NoMethodError, "undefined method `#{meth}' for #{obj}:Class"
-    ##end
-    thread_id, call_id = Thread.current.object_id.abs, obj.object_id.abs
-    meth_alias = "__benelux_#{meth}_#{thread_id}_#{call_id}"
-    obj.module_eval do
-      alias_method meth_alias, meth
-    end
-    meth_alias
+  # This is an instance method for objects which have Benelux 
+  # modified methods.
+  def counted_methods
+    Benelux.counted_methods.filter(:class => self.class.to_s.to_sym)
   end
 
-  # Creates a method definition (for an `eval` that) for a method
-  # named +meth+ which times a call to +meth_alias+. 
-  def Benelux.generate_timer_str(meth_alias, meth)
-    %Q{
-    def #{meth}(*args, &block)
-      call_id = "" << self.object_id.abs.to_s << args.object_id.abs.to_s
-      # We only need to do these things once.
-      if self.timeline.nil?
-        self.timeline = Benelux::Timeline.new
-        Benelux.store_thread_reference
-      end
-      mark_a = self.timeline.add_mark :'#{meth}_a'
-      mark_a.add_tag :call_id => call_id
-      tags = mark_a.tags
-      ret = #{meth_alias}(*args, &block)
-    rescue => ex
-      raise ex
-    ensure
-      mark_z = self.timeline.add_mark :'#{meth}_z'
-      mark_z.tags = tags # In case tags were added between these marks
-      range = self.timeline.add_range :'#{meth}', mark_a, mark_z
-      range.exception = ex if defined?(ex) && !ex.nil?
-    end
-    }
-  end
+  
+  def Benelux.enable_debug; @@debug = true; end
+  def Benelux.disable_debug; @@debug = false; end
+  def Benelux.debug?; @@debug; end
+  
   
 end
 
 
 
 
+__END__
+ %   cumulative   self              self     total
+time   seconds   seconds    calls  ms/call  ms/call  name
+33.04    40.39     40.39   832483     0.05     0.10  Selectable::Tags#==
+20.65    65.64     25.25   824759     0.03     0.04  Hash#==
+15.38    84.44     18.80     8173     2.30    12.16  Array#select
+ 6.94    92.93      8.49      101    84.06    84.06  Thread#join
+ 6.42   100.78      7.85   927328     0.01     0.01  String#==
+ 5.42   107.40      6.62   832912     0.01     0.01  Kernel.is_a?
+ 2.01   109.86      2.46    23840     0.10     5.13  Array#each
+ 0.85   110.90      1.04     9577     0.11     0.46  Selectable::Tags#>=
+ 0.83   111.92      1.02    13295     0.08     0.87  Kernel.send
+ 0.67   112.74      0.82     6348     0.13     0.18  Benelux::Stats::Calculator#update
+ 0.46   113.30      0.56      238     2.35    10.50  Kernel.require
+ 0.41   113.80      0.50    10620     0.05     0.22  Object#metaclass
+ 0.36   114.24      0.44    10776     0.04     0.15  Object#metaclass?
+ 0.35   114.67      0.43     9900     0.04     0.08  Gibbler::Digest#==
+ 0.35   115.10      0.43     6348     0.07     0.26  Benelux::Stats::Calculator#sample