benelux 0.4.2 → 0.5.0

data/CHANGES.txt

@@ -1,6 +1,21 @@
 BENELUX, CHANGES
 
 
+#### 0.4.4 (2009-10-20) ###############################
+
+* CHANGE: Removed reporter
+* CHANGE: Take advantage of Ruby's accidentally thread-safe 
+  Arrays and use global timeline
+* CHANGE: Removed Timeline#counts
+
+
+#### 0.4.3 (2009-10-08) ###############################
+
+* FIXED: Initial reporting loop waits 1 second for first threads
+* CHANGE: Huge performance improvement (no tag matching when merging stats)
+* CHANGED: Cleaned Reporter
+
+
 #### 0.4.2 (2009-10-06) ###############################
 
 * ADDED: JRuby support

data/benelux.gemspec

@@ -1,7 +1,7 @@
 @spec = Gem::Specification.new do |s|
   s.name = "benelux"
   s.rubyforge_project = 'benelux'
-  s.version = "0.4.2"
+  s.version = "0.5.0"
   s.summary = "Benelux: Little freakin' timers for your Ruby codes"
   s.description = s.summary
   s.author = "Delano Mandelbaum"
@@ -46,6 +46,7 @@
   tryouts/30_timeline_tryouts.rb
   tryouts/proofs/alias_performance.rb
   tryouts/proofs/array_performance.rb
+  tryouts/proofs/thread_array.rb
   tryouts/proofs/timer_threading.rb
   )
 

data/lib/benelux/packer.rb

@@ -95,16 +95,16 @@ module Benelux
       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 = Benelux.thread_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 = Benelux.thread_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 = Benelux.thread_timeline.add_range :'#{@meth}', mark_a, mark_z
         range.exception = ex if defined?(ex) && !ex.nil?
       end
       }

data/lib/benelux/reporter.rb

@@ -9,46 +9,46 @@ module Benelux
       @abort, @running = false, false
       @tmerge = Benelux::Stats::Calculator.new
       add_threads *threads
+      @tbd = []
+      @thread = create_reporting_thread
+    end
+    def create_reporting_thread(priority=-3)
+      t = Thread.new do
+        5.times {  # Give the app 1 second to generate threads
+          break if @start && !@thwait.empty?
+          sleep 0.2
+        }
+        
+        run_loop
+      end
+      t.priority = priority
+      t
     end
     def add_threads(*threads)
       threads.each do |thread|
-        #raise BadRecursion, "Cannot report on self" if thread == Thread.current
+        raise BadRecursion, "Cannot report on self" if thread == @thread
         next if thread == Thread.main
         @thwait.join_nowait thread
       end
-      return if running?
-      @@mutex.synchronize do
-        start
-      end
+      @start = true
     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
+      !@thwait.threads.select { |t| !t.nil? && t.status }.empty?
     end
+
     def run_loop
       loop do
         break if @abort
         process(@tbd)
         if @thwait.empty?
-          sleep 0.001
+          sleep 0.01 # prevent mad thrashing. 
+          # If there are no threads running we can stop 
+          # because there are none waiting in the queue. 
           running_threads? ? next : break
         end
         t = @thwait.next_wait
-        #p [:reporter_queue, '^', t.track_name, @thread.priority]
         @tbd << t.timeline
       end
     end
@@ -64,12 +64,16 @@ module Benelux
     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 
+    # that thread.
     def force_update
       @abort = false
       @tbd << Thread.current.timeline
       run_loop
     end
+    # Call this once the active threads have stopped. It
+    # increases the priority of the processing thread, 
+    # waits for it to finish and then calls force_update
+    # to get the main threads stats into the timeline. 
     def wait
       if @thread && Thread.current == Thread.main
         @abort = true

data/lib/benelux/stats.rb

@@ -15,6 +15,9 @@ module Benelux
       g.name = name
       g
     end
+    def size
+      @names.size
+    end
     # Each group
     def each(&blk)
       @names.each { |name| blk.call(group(name)) }
@@ -43,13 +46,12 @@ module Benelux
       if !other.is_a?(Benelux::Stats)
         raise TypeError, "can't convert #{other.class} into Stats" 
       end
+      s = self.clone
       other.names.each do |name|
-        add_group name
-        a = self.send(name) 
-        a += other.send(name)
-        a
+        s.add_group name
+        s.group(name) << other.group(name)
       end
-      self
+      s
     end
     
     class Group < Array
@@ -61,28 +63,35 @@ module Benelux
         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 }
-          # 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
+        g = Group.new self
+        g.name = @name
+        g << other
+        g
+      end
+      
+      def <<(other)
+        self.push *other
         self
       end
       
+      def merge(*tags)
+        #tags = Selectable.normalize tags
+        mc = Calculator.new
+        mc.init_tags!
+        all = tags.empty? ? self : self.filter(tags)
+        all.each { |calc| 
+          mc.merge! calc
+          mc.add_tags_quick calc.tags
+        }    
+        mc
+      end
+      
       def sample(s, tags={})
-        raise BeneluxError, "tags must be a Hash" unless tags.kind_of?(Hash)
-        calcs = self.select { |c| c.tags == tags }
-        if calcs.empty?
-          (c = Calculator.new).add_tags tags
-          self << c
-          calcs = [c]
-        end
-        calcs.each { |c| c.sample(s) }
+        raise BeneluxError, "tags must be a Hash" unless Hash === tags
+        c = Calculator.new
+        c.add_tags tags
+        c.sample s
+        self << c
         nil
       end
       
@@ -99,18 +108,6 @@ module Benelux
       def sd()      merge.sd     end
       def n()       merge.n      end
       
-      def merge(*tags)
-        tags = Selectable.normalize tags
-        mc = Calculator.new
-        mc.init_tags!
-        all = tags.empty? ? self : self.filter(tags)
-        all.each { |calc| 
-          mc.merge! calc
-          mc.add_tags_quick calc.tags
-        }
-        mc
-      end
-      
       def filter(*tags)
         (f = super).name = @name
         f
@@ -172,7 +169,14 @@ module Benelux
         end
         @n+=1
       end
-  
+      
+      def first_tick() @last_time = Time.now end
+      def tick
+        tick_time = Time.now
+        sample(tick_time - @last_time)
+        @last_time = tick_time
+      end
+      
       # Dump this Stats object with an optional additional message.
       def dump(msg = "", out=STDERR)
         out.puts "#{msg}: #{self.report}"
@@ -209,6 +213,7 @@ module Benelux
       end
       
       def ==(other)
+        return false unless self.class == other.class
         a=([@sum, @min, @max, @n, @sumsq] - 
            [other.sum, other.min, other.max, other.n, other.sumsq])
         a.empty?

data/lib/benelux/timeline.rb

@@ -21,13 +21,11 @@ module Benelux
     include Selectable
     
     attr_accessor :ranges
-    attr_accessor :counts
     attr_accessor :stats
     attr_accessor :default_tags
     attr_reader :caller
     def initialize(*args)
       @caller = Kernel.caller
-      @counts = SelectableArray.new
       @ranges = SelectableArray.new
       @default_tags = Selectable::Tags.new
       @stats = Benelux::Stats.new
@@ -97,14 +95,6 @@ module Benelux
       end
     end
     
-    def counts(name=nil, tags=Selectable::Tags.new)
-      return @counts if name.nil?
-      @counts.select do |count| 
-        ret = name.to_s == count.name.to_s &&
-        (tags.nil? || count.tags >= tags)
-        ret
-      end
-    end
     #
     #     obj.regions(:do_request) =>
     #         
@@ -133,14 +123,11 @@ module Benelux
       super
     end
     
-    # TODO: Remove Benelux::Count. Just use Stats!
     def add_count(name, count, tags={})
       tags = tags.merge self.default_tags
-      c = Benelux::Count.new(name, count)
-      c.add_tags tags
       self.stats.add_group(name)
-      self.stats.sample(name, count, c.tags)
-      c
+      self.stats.sample(name, count, tags)
+      count
     end
     
     def add_mark(name)

data/lib/benelux.rb

@@ -5,7 +5,7 @@ require 'thwait'
 require 'selectable'
 
 module Benelux
-  VERSION = "0.4.2"
+  VERSION = "0.5.0"
   NOTSUPPORTED = [Class, Object, Kernel]
   
   class BeneluxError < RuntimeError; end
@@ -20,7 +20,6 @@ module Benelux
   require 'benelux/range'
   require 'benelux/stats'
   require 'benelux/packer'
-  require 'benelux/reporter'
   require 'benelux/timeline'
   require 'benelux/mixins/thread'
   require 'benelux/mixins/symbol'
@@ -29,13 +28,13 @@ module Benelux
     attr_reader :packed_methods
     attr_reader :tracks
     attr_reader :timeline
-    attr_reader :reporter
+    attr_reader :known_threads
   end
   
   @packed_methods = {}
   @tracks = SelectableHash.new
   @timeline = Timeline.new
-  @reporter = Reporter.new
+  @known_threads = []
   
   @@mutex = Mutex.new
   @@debug = false
@@ -70,16 +69,25 @@ module Benelux
       @@mutex.synchronize do
         @tracks[name] ||= Track.new(name, group)
         @tracks[name].add_thread Thread.current
-        @reporter.add_thread Thread.current
+        @known_threads << Thread.current
       end
     end
     Benelux.track(name)
   end
   Benelux.current_track :main
   
+  # Only updates data from threads that are dead
+  def Benelux.update_global_timeline
+    dthreads = Benelux.known_threads.select { |t| 
+      !t.timeline.nil? && (t.nil? || !t.status)
+    }
+    # We don't need to make a special case for the 
+    # current thread b/c the current is not dead. 
+    Benelux.timeline.merge! *dthreads.collect { |t| t.timeline }
+  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
@@ -102,15 +110,7 @@ module Benelux
 
   
   def Benelux.known_thread?(t=Thread.current)
-    @reporter.thwait.threads.member? t
-  end
-  
-  def Benelux.known_threads
-    @reporter.thwait.threads
-  end
-  
-  def Benelux.reporting_wait
-    @reporter.wait
+    Benelux.known_threads.member? t
   end
   
   def Benelux.packed_method(klass, meth)

data/tryouts/proofs/array_performance.rb

@@ -1,5 +1,5 @@
 
-tryouts "Array speed", :benchmark do
+xtryouts "Array speed", :benchmark do
   set :base, []
   
   drill "Populate array" do
@@ -31,3 +31,27 @@ tryouts "Array speed", :benchmark do
   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

@@ -0,0 +1,49 @@
+
+
+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?

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: benelux
 version: !ruby/object:Gem::Version 
-  version: 0.4.2
+  version: 0.5.0
 platform: ruby
 authors: 
 - Delano Mandelbaum
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-10-06 00:00:00 -04:00
+date: 2009-10-21 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -61,6 +61,7 @@ files:
 - tryouts/30_timeline_tryouts.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