benelux 0.3.2 → 0.4.1

data/lib/benelux/count.rb

@@ -0,0 +1,29 @@
+module Benelux
+  
+  class Count
+    include Selectable::Object
+    attr_accessor :name
+    def initialize(name, count)
+      @name, @count = name, count
+    end
+    def track 
+      @tags[:track]
+    end
+    def inspect
+      "#<%s:%s count=%d name=%s %s>" % [self.class, hexoid, self.to_i, name, tags]
+    end
+    def to_i
+      @count.to_i
+    end
+    def to_s
+      @count.to_s
+    end
+    def ==(other)
+      self.class == other.class &&
+      self.name == other.name &&
+      self.tags == other.tags &&
+      @count.to_i == other.to_i
+    end
+
+  end
+end

data/lib/benelux/mark.rb

@@ -1,24 +1,16 @@
 module Benelux
   class Mark < Time
-    include Benelux::TagHelpers
+    include Selectable::Object
     attr_accessor :name
     def self.now(n=nil)
       v = super()
-      v.tags = Benelux::Tags.new
+      v.tags = Selectable::Tags.new
       v.name = n 
       v
     end
     def track 
       @tags[:track]
     end
-    def add_tags(tags=Benelux::Tags.new)
-      @tags.merge! tags
-    end
-    alias_method :add_tag, :add_tags
-    def remove_tags(*tags)
-      @tags.delete_if { |n,v| tags.member?(n) }
-    end
-    alias_method :remove_tag, :remove_tags
     def inspect(reftime=nil)
       val = reftime.nil? ? self : (reftime - self)
       "#<%s:%s at=%f name=%s %s>" % [self.class, hexoid, to_f, name, tags]
@@ -31,7 +23,6 @@ module Benelux
       self - time
     end
     def ==(other)
-      return false unless other.respond_to? :call_id
       self.name == other.name &&
       self.tags == other.tags &&
       self.to_f == self.to_f

data/lib/benelux/mixins/symbol.rb

@@ -0,0 +1,8 @@
+
+#if RUBY_VERSION =~ /1.8/
+  class Symbol
+    def <=>(other)
+      self.to_s <=> other.to_s
+    end
+  end
+#end

data/lib/benelux/mixins/thread.rb

@@ -3,5 +3,5 @@
 class Thread
   extend Attic
   attic :timeline
-  attic :track
+  attic :track_name
 end

data/lib/benelux/packer.rb

@@ -0,0 +1,138 @@
+
+
+module Benelux
+  class MethodPacker
+    include Selectable::Object
+    
+    attr_accessor :aliaz
+    attr_reader   :klass
+    attr_reader   :meth
+    attr_reader   :blk
+    
+    # * +k+ is a class
+    # * +m+ is the name of an instance method in +k+
+    # 
+    # This method makes the following changes to class +k+. 
+    #
+    # * Add a timeline attic to and include +Benelux+ 
+    # * Rename the method to something like:
+    #   __benelux_execute_2151884308_2165479316
+    # * Install a new method with the name +m+.
+    #
+    def initialize(k,m,&blk)
+      Benelux.ld "%20s: %s#%s" % [self.class, k, m]
+      if Benelux.packed_method? k, m
+        raise SelectableError, "Already defined (#{k} #{m})"
+      end
+      @klass, @meth, @blk = k, m, blk
+      @klass.extend Attic  unless @klass.kind_of?(Attic)
+      unless @klass.kind_of?(Benelux)
+        @klass.attic :timeline
+        @klass.send :include, Benelux
+      end
+      ## 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, @klass.object_id.abs
+      @aliaz = a = :"__benelux_#{@meth}_#{thread_id}_#{call_id}"
+      Benelux.ld "%20s: %s" % ['Alias', @aliaz] 
+      @klass.module_eval do
+        alias_method a, m  # Can't use the instance variables
+      end
+      install_method  # see generate_packed_method
+      self.add_tags :class => @klass.to_s.to_sym, 
+                    :meth  => @meth.to_sym,
+                    :kind  => self.class.to_s.to_sym
+      Benelux.packed_methods << self
+    end
+    def install_method
+      raise "You need to implement this method"
+    end
+    # instance_exec for Ruby 1.8 written by Mauricio Fernandez
+    # http://eigenclass.org/hiki/instance_exec
+    if RUBY_VERSION =~ /1.8/
+      module InstanceExecHelper; end
+      include InstanceExecHelper
+      def instance_exec(*args, &block) # !> method redefined; discarding old instance_exec
+        mname = "__instance_exec_#{Thread.current.object_id.abs}_#{object_id.abs}"
+        InstanceExecHelper.module_eval{ define_method(mname, &block) }
+        begin
+          ret = send(mname, *args)
+        ensure
+          InstanceExecHelper.module_eval{ undef_method(mname) } rescue nil
+        end
+        ret
+      end
+    end
+    def run_block(*args)
+      raise "must implement"
+    end
+  end
+  
+  class MethodTimer < MethodPacker
+    # This method executes the method definition created by
+    # generate_method. It calls <tt>@klass.module_eval</tt> 
+    # with the modified line number (helpful for exceptions)
+    def install_method
+      @klass.module_eval generate_packed_method, __FILE__, 89
+    end
+    
+    # Creates a method definition (for an eval). The 
+    # method is named +@meth+ and it calls +@aliaz+.
+    #
+    # The new method adds a Mark to the thread timeline
+    # before and after +@alias+ is called. It also adds
+    # a Range to the timeline based on the two marks. 
+    def generate_packed_method
+      %Q{
+      def #{@meth}(*args, &block)
+        call_id = "" << self.object_id.abs.to_s << args.object_id.abs.to_s
+        Benelux.current_track :global unless Benelux.known_thread?
+        mark_a = Thread.current.timeline.add_mark :'#{@meth}_a'
+        mark_a.add_tag :call_id => call_id
+        tags = mark_a.tags
+        ret = #{@aliaz}(*args, &block)
+      rescue => ex  # We do this so we can use
+        raise ex    # ex in the ensure block.
+      ensure
+        mark_z = Thread.current.timeline.add_mark :'#{@meth}_z'
+        mark_z.tags = tags # In case tags were added between these marks
+        range = Thread.current.timeline.add_range :'#{@meth}', mark_a, mark_z
+        range.exception = ex if defined?(ex) && !ex.nil?
+      end
+      }
+    end
+  end
+  
+  class MethodCounter < MethodPacker
+    attr_reader :counter
+    def install_method
+      @klass.module_eval generate_packed_method, __FILE__, 121
+    end
+    
+    def generate_packed_method(callblock=false)
+      %Q{
+      @@__benelux_#{@meth}_counter = 
+        Benelux.counted_method #{@klass}, :#{@meth}
+      def #{@meth}(*args, &block)
+        Benelux.current_track :global unless Benelux.known_thread?
+        # Get a reference to this MethodCounter instance
+        cmd = Benelux.counted_method #{@klass}, :#{@meth}
+        ret = #{@aliaz}(*args, &block)
+        count = cmd.determine_count(args, ret)
+        Benelux.ld "COUNT(:#{@meth}): \#{count}"
+        Benelux.thread_timeline.add_count :'#{@meth}', count
+        ret
+      end
+      }
+    end
+    
+    def determine_count(args,ret)
+      return 1 if @blk.nil?
+      self.instance_exec args, ret, &blk
+    end
+    
+  end
+end

data/lib/benelux/range.rb

@@ -1,7 +1,7 @@
 
 module Benelux
   class Range
-    include Benelux::TagHelpers
+    include Selectable::Object
     
     attr_accessor :name
     attr_accessor :from
@@ -9,7 +9,7 @@ module Benelux
     attr_accessor :exception
     def initialize(name,from,to)
       @name, @from, @to = name, from, to
-      @tags = Benelux::Tags.new
+      @tags = Selectable::Tags.new
     end
     def to_s
       "%s:%.4f" % [name, duration]

data/lib/benelux/reporter.rb

@@ -0,0 +1,89 @@
+
+module Benelux
+  class Reporter
+    attr_reader :thread
+    attr_reader :thwait
+    @@mutex = Mutex.new
+    def initialize(*threads)
+      @thwait = ThreadsWait.new
+      @abort, @running = false, false
+      @tmerge = Benelux::Stats::Calculator.new
+      add_threads *threads
+    end
+    def add_threads(*threads)
+      threads.each do |thread|
+        #raise BadRecursion, "Cannot report on self" if thread == Thread.current
+        next if thread == Thread.main
+        @thwait.join_nowait thread
+      end
+      return if running?
+      @@mutex.synchronize do
+        start
+      end
+    end
+    alias_method :add_thread, :add_threads
+    def running_threads?
+      # Any status that is not nil or false is running
+      !@thwait.threads.select { |t| t.status }.empty?
+    end
+    
+    def start
+      return if running?
+      @running = true
+      @thread = Thread.new do
+        while @thwait.empty?
+          sleep 0.5   # Give the app time to generate threads
+        end
+        @tbd = []
+        run_loop
+      end
+      @thread.priority = -3
+    end
+    def run_loop
+      loop do
+        break if @abort
+        process(@tbd)
+        if @thwait.empty?
+          sleep 0.001
+          running_threads? ? next : break
+        end
+        t = @thwait.next_wait
+        #p [:reporter_queue, '^', t.track_name, @thread.priority]
+        @tbd << t.timeline
+      end
+    end
+    def process(tbd)
+      return if tbd.empty?
+      (start = Time.now)
+      Benelux.timeline.merge! *tbd
+      (endt = Time.now)
+      dur = (endt - start).to_f
+      #p [:processed, tbd.size, dur]
+      tbd.clear
+      @tmerge.sample dur
+    end
+    # We don't add the main thread to the wait group
+    # so we need to manually force processing for
+    # that thread. The reason: we 
+    def force_update
+      @abort = false
+      @tbd << Thread.current.timeline
+      run_loop
+    end
+    def wait
+      if @thread && Thread.current == Thread.main
+        @abort = true
+        @thread.priority = 0
+        @thread.join if @thread.status
+        force_update
+      else
+        msg = "Not main thread. Skipping call to wait from #{caller[0]}"
+        Benelux.ld msg
+      end
+    end
+    def stop() @abort = true end
+    def done?()     @done  end
+    def aborted?()  @abort end
+    def running?()  @running end
+  end
+end

data/lib/benelux/stats.rb

@@ -2,31 +2,41 @@
 module Benelux
   class Stats
     attr_reader :names
+    
     def initialize(*names)
       @names = []
-      add_keepers names
+      add_groups names
+    end
+    def group(name)
+      @names.member?(name) ? self.send(name) : create_zero_group(name)
     end
-    def get_keeper(name)
-      self.send name
+    def create_zero_group(name)
+      g = Benelux::Stats::Group.new
+      g.name = name
+      g
     end
-    # Each keeper
+    # Each group
     def each(&blk)
-      @names.each { |name| blk.call(get_keeper(name)) }
+      @names.each { |name| blk.call(group(name)) }
     end
-    # Each keeper name, keeper
+    # Each group name, group
     def each_pair(&blk)
-      @names.each { |name| blk.call(name, get_keeper(name)) }
+      @names.each { |name| blk.call(name, group(name)) }
     end
-    def add_keepers(*args)
+    def add_groups(*args)
       args.flatten.each do |meth|
-        next if has_keeper? meth
+        next if has_group? meth
         @names << meth
         self.class.send :attr_reader, meth
-        instance_variable_set("@#{meth}", Benelux::Stats::Group.new(meth))
+        (g = Benelux::Stats::Group.new).name = meth
+        instance_variable_set("@#{meth}", g)
       end
     end
-    alias_method :add_keeper, :add_keepers
-    def has_keeper?(name)
+    def sample(name, s, tags={})
+      self.send(name).sample(s, tags)
+    end
+    alias_method :add_group, :add_groups
+    def has_group?(name)
       @names.member? name
     end
     def +(other)
@@ -34,7 +44,7 @@ module Benelux
         raise TypeError, "can't convert #{other.class} into Stats" 
       end
       other.names.each do |name|
-        add_keeper name
+        add_group name
         a = self.send(name) 
         a += other.send(name)
         a
@@ -43,23 +53,23 @@ module Benelux
     end
     
     class Group < Array
-      attr_reader :name
-      def initialize(name)
-        @name = name
-      end
+      include Selectable
+      
+      attr_accessor :name
       
       def +(other)
         unless @name == other.name
           raise BeneluxError, "Cannot add #{other.name} to #{@name}"
         end
         other.each do |newcalc|
+          # Merge calculator with a like calculator in another group.
           calcs = self.select { |calc| calc.tags == newcalc.tags }
-          self << newcalc and next if calcs.empty?
           # This should only ever contain one b/c we should
           # not have several calculators with the same tags. 
           calcs.each do |calc|
             calc += newcalc
           end
+          self << newcalc
         end
         self
       end
@@ -76,37 +86,42 @@ module Benelux
         nil
       end
       
+      def tag_values(tag)
+        vals = self.collect { |calc| calc.tags[tag] }
+        Array.new vals.uniq
+      end
+      
+      def tags()    merge.tags   end
       def mean()    merge.mean   end
       def min()     merge.min    end
       def max()     merge.max    end
+      def sum()     merge.sum    end
       def sd()      merge.sd     end
       def n()       merge.n      end
       
-      def merge(tags={})
-#        tags = Benelux::TagHelpers.normalize tags
+      def merge(*tags)
+        tags = Selectable.normalize tags
         mc = Calculator.new
+        mc.init_tags!
         all = tags.empty? ? self : self.filter(tags)
         all.each { |calc| 
-          mc.samples calc
-          mc.add_tags calc.tags
+          mc.merge! calc
+          mc.add_tags_quick calc.tags
         }
         mc
       end
       
-      def [](tags={})
-#        tags = Benelux::TagHelpers.normalize tags
-        g = Benelux::Stats::Group.new @name
-        g << self.select { |c| c.tags >= tags }
-        g.flatten!(1)  # only 1 level deep
-        g
+      def filter(*tags)
+        (f = super).name = @name
+        f
       end
-      alias_method :filter, :[]
+      alias_method :[], :filter
       
     end
     
     # Based on Mongrel::Stats, Copyright (c) 2005 Zed A. Shaw
-    class Calculator < Array
-      include Benelux::TagHelpers
+    class Calculator
+      include Selectable::Object
       
       attr_reader :sum, :sumsq, :n, :min, :max
 
@@ -115,16 +130,15 @@ module Benelux
       end
   
       def +(other)
-        super(other)
-        self.recalculate
-        self
+        c = Calculator.new
+        c.merge! self
+        c.merge! other
+        c
       end
   
       # Resets the internal counters so you can start sampling again.
       def reset
-        self.clear
         @n, @sum, @sumsq = 0.0, 0.0, 0.0
-        @last_time = 0.0
         @min, @max = 0.0, 0.0
       end
       
@@ -132,13 +146,22 @@ module Benelux
         args.flatten.each { |s| sample(s) }
       end
       
+      def merge!(other)      
+        if @sum == 0
+          @min = @max = other.mean
+        else
+          @min = other.min if other.min < @min
+          @max = other.max if other.max > @max
+        end
+        @sum += other.sum
+        @sumsq += other.sumsq
+        @n += other.n
+
+        self
+      end
+      
       # Adds a sampling to the calculations.
       def sample(s)
-        self << s
-        update s
-      end
-  
-      def update(s)
         @sum += s
         @sumsq += s * s
         if @n == 0
@@ -184,13 +207,13 @@ module Benelux
           return 0.0
         end
       end
-  
-      def recalculate
-        samples = self.clone
-        reset
-        samples.each { |s| sample(s) }
+      
+      def ==(other)
+        a=([@sum, @min, @max, @n, @sumsq] - 
+           [other.sum, other.min, other.max, other.n, other.sumsq])
+        a.empty?
       end
-  
+      
     end