jstorimer-deep-test 0.2.0 → 1.0.0

data/lib/deep_test/extensions/drb_extension.rb

@@ -0,0 +1,34 @@
+module DeepTest
+  class DRbBindAllTCPSocket < DRb::DRbTCPSocket
+    def self.parse_uri(uri)
+      if uri =~ /^drubyall:\/\/(.*?):(\d+)(\?(.*))?$/
+      	host = $1
+      	port = $2.to_i
+      	option = $4
+      	[host, port, option]
+      else
+      	raise(DRb::DRbBadScheme, uri) unless uri =~ /^drubyall:/
+      	raise(DRb::DRbBadURI, 'can\'t parse uri:' + uri)
+    	end
+    end
+
+    # Open a server listening for connections at +uri+ using 
+    # configuration +config+.
+    def self.open_server(uri, config)
+      uri = 'drubyall://:0' unless uri
+      host, port, opt = parse_uri(uri)
+
+      if host.size == 0
+        host = getservername
+      end
+
+      DeepTest.logger.debug("Listening on port #{port}, all addresses.")
+	    soc = TCPServer.open('0.0.0.0', port)  	    
+      port = soc.addr[1] if port == 0
+      uri = "druby://#{host}:#{port}"
+      self.new(uri, soc, config)
+    end
+  end
+end
+
+DRb::DRbProtocol.add_protocol DeepTest::DRbBindAllTCPSocket

data/lib/deep_test/listener_list.rb

@@ -6,7 +6,7 @@ module DeepTest
       @listeners = listeners
     end
 
-    NullListener.instance_methods(false).each do |event|
+    NullWorkerListener.instance_methods(false).each do |event|
       eval <<-end_src
         def #{event}(*args)
           @listeners.each {|l| l.#{event}(*args)}

data/lib/deep_test/local_workers.rb

@@ -0,0 +1,55 @@
+module DeepTest
+  class LocalWorkers
+    def initialize(options)
+      @options = options
+      @warlock = Warlock.new
+    end
+
+    def load_files(files)
+      files.each {|f| load f}
+    end
+
+    def server
+      @options.server
+    end
+
+    def start_all
+      each_worker do |worker_num|
+        start_worker(worker_num) do
+          reseed_random_numbers
+          reconnect_to_database
+          worker = DeepTest::Worker.new(worker_num,
+                                        server, 
+                                        @options.new_listener_list)
+          worker.run
+        end
+      end        
+    end
+
+    def stop_all
+      @warlock.stop_all
+    end
+
+    def number_of_workers
+      @options.number_of_workers
+    end
+
+    private
+
+    def reconnect_to_database
+      ActiveRecord::Base.connection.reconnect! if defined?(ActiveRecord::Base)
+    end
+
+    def start_worker(worker_num, &blk)
+      @warlock.start("worker #{worker_num}", &blk)
+    end
+
+    def reseed_random_numbers
+      srand
+    end
+
+    def each_worker
+      number_of_workers.to_i.times { |worker_num| yield worker_num }
+    end
+  end
+end

data/lib/deep_test/logger.rb

@@ -2,31 +2,16 @@ module DeepTest
   class Logger < ::Logger
     def initialize(*args)
       super
-      hostname = Socket.gethostname
-      self.formatter = proc { |severity, time, progname, msg| "[DeepTest@#{hostname}] #{time.strftime "%F %T"} #{msg}\n" }
+      self.formatter = proc { |severity, time, progname, msg| "[DeepTest] #{msg}\n" }
       self.level = configured_log_level
     end
 
-    def io_stream
-      @logdev.dev
-    end
-
     def configured_log_level
       if ENV['DEEP_TEST_LOG_LEVEL']
-        Logger.const_get(ENV['DEEP_TEST_LOG_LEVEL'].upcase)
+        Logger.const_get(ENV['DEEP_TEST_LOG_LEVEL'])
       else
         Logger::INFO
       end
     end
-
-    Severity.constants.each do |severity|
-      eval <<-end_src
-        def #{severity.downcase}
-          super
-        rescue Exception => e
-          super "\#{e.class}: \#{e} occurred logging on \#{caller[0]}", &nil
-        end
-      end_src
-    end
   end
 end

data/lib/deep_test/marshallable_exception_wrapper.rb

@@ -19,8 +19,8 @@ module DeepTest
         klass = eval("::" + classname) 
         resolved_message = message
       rescue => e
-        DeepTest.logger.debug { "Unable to load exception class: #{classname}: #{e.message}" }
-        DeepTest.logger.debug { e.backtrace.join("\n") }
+        DeepTest.logger.debug("Unable to load exception class: #{classname}: #{e.message}")
+        DeepTest.logger.debug(e.backtrace.join("\n"))
 
         klass = UnloadableException
         resolved_message = "#{classname}: #{message}"
@@ -29,8 +29,8 @@ module DeepTest
       begin
         resolved_exception = klass.new resolved_message
       rescue => e
-        DeepTest.logger.debug { "Unable to instantiation exception class: #{classname}: #{e.message}" }
-        DeepTest.logger.debug { e.backtrace.join("\n") }
+        DeepTest.logger.debug("Unable to instantiation exception class: #{classname}: #{e.message}")
+        DeepTest.logger.debug(e.backtrace.join("\n"))
 
         resolved_exception = UnloadableException.new resolved_message
       end

data/lib/deep_test/metrics/gatherer.rb

@@ -0,0 +1,67 @@
+module DeepTest
+  module Metrics
+    class Gatherer
+      def self.setup(options)
+        $metrics_gatherer = new(options)
+
+        at_exit do
+          $metrics_gatherer.write_file
+        end
+      end
+
+      def self.enabled?
+        return false unless $metrics_gatherer
+        $metrics_gatherer.enabled?
+      end
+
+      def self.section(title, &block)
+        $metrics_gatherer.section(title, &block)
+      end
+
+      def initialize(options)
+        @options = options
+        @sections = []
+      end
+
+      def enabled?
+        !@options.metrics_file.nil?
+      end
+
+      def section(title, &block)
+        @sections << Section.new(title, &block) if enabled?
+      end
+
+      def render
+        @sections.map {|s| s.render}.join("\n")
+      end
+      
+      def write_file
+        return unless enabled?
+        File.open(@options.metrics_file, "w") do |io|
+          io << render
+        end
+      end
+
+      class Section
+        def initialize(title, &generate_measurements_block)
+          @title = title
+          @generate_measurements_block = generate_measurements_block
+        end
+
+        def measurement(name, value)
+          @measurements << [name, value]
+        end
+
+        def gather_measurements
+          @measurements = []
+          @generate_measurements_block.call(self)
+        end
+
+        def render
+          gather_measurements
+          "[#{@title}]\n" + @measurements.map {|name, value| "#{name}: #{value}"}.join("\n")
+        end
+      end
+    end
+  end
+end

data/lib/deep_test/metrics/queue_lock_wait_time_measurement.rb

@@ -0,0 +1,133 @@
+module DeepTest
+  module Metrics
+    module QueueLockWaitTimeMeasurement
+      attr_reader :total_pop_time, :total_push_time
+
+      def self.extended(o)
+        o.instance_eval do
+          alias pop_without_lock_wait_measurement pop
+          alias pop pop_with_lock_wait_measurement
+
+          alias push_without_lock_wait_measurement push
+          alias push push_with_lock_wait_measurement
+        end
+      end
+
+      def pop_with_lock_wait_measurement(no_wait = false)
+        if no_wait
+          return measure(:add_pop_time) do
+            pop_without_lock_wait_measurement(no_wait)
+          end
+        else
+          begin
+            # Measure without waiting to minimize extra time added
+            # above locking time
+            #
+            return measure(:add_pop_time) do
+              pop_without_lock_wait_measurement(true)
+            end
+          rescue ThreadError => e
+            if e.message == "queue empty"
+              # Normally we would have waiting for a condvar signal,
+              # so don't penalize time for locking here again - hence
+              # no measure
+              return pop_without_lock_wait_measurement(false)
+            else
+              raise
+            end
+          end
+        end
+      end
+
+      def push_with_lock_wait_measurement(value)
+        measure(:add_push_time) do
+          push_without_lock_wait_measurement(value)
+        end
+      end
+
+      def measure(accumulator)
+        start_time = Time.now
+        result = yield
+        send(accumulator, Time.now - start_time)
+        result
+      end
+
+      def add_push_time(time)
+        Thread.exclusive do
+          @total_push_time ||= 0
+          @total_push_time += time
+        end
+      end
+
+      def add_pop_time(time)
+        Thread.exclusive do
+          @total_pop_time ||= 0
+          @total_pop_time += time
+        end
+      end
+    end
+  end
+end
+
+
+if $0 == __FILE__
+  require 'thread'
+  require 'timeout'
+
+  thread_count = (ARGV[0] || 10).to_i
+  action_count = (ARGV[1] || 100).to_i
+
+  def test_measurement(thread_count, action_count)
+    q = Queue.new
+    q.extend DeepTest::Metrics::QueueLockWaitTimeMeasurement
+
+    threads = []
+    thread_count.times do
+      threads << Thread.new do
+        action_count.times do |i|
+          show_progress ".", action_count, i
+          q.push 1
+        end
+      end
+    end
+
+    thread_count.times do
+      threads << Thread.new do
+        action_count.times do |i|
+          show_progress "-", action_count, i
+          if rand(2) == 0
+            begin
+              q.pop(true)
+            rescue ThreadError
+            end
+          else
+            begin
+              Timeout.timeout(0.01) do
+                q.pop
+              end
+            rescue Timeout::Error
+              break
+            end
+          end
+        end
+      end
+    end
+
+    threads.each {|t| t.join}
+
+    puts
+    puts "Push Time: #{q.total_push_time}"
+    puts "Pop Time:  #{q.total_pop_time}"
+  end
+
+  def show_progress(s, total, current)
+    if (current % (total / 5)) == 0
+      $stdout.print s
+      $stdout.flush
+    end
+  end
+
+  start_time = Time.now
+  test_measurement(thread_count, action_count)
+  puts "Total Run Time:  #{Time.now - start_time}"
+end

data/lib/deep_test/{null_listener.rb → null_worker_listener.rb}

@@ -2,7 +2,7 @@ module DeepTest
   #
   # Listener that implements no-ops for all callbacks that DeepTest supports.
   #
-  class NullListener
+  class NullWorkerListener
     #
     # Before DeepTest synchronizes any code during a distributed run,
     # before_sync is called.  If DeepTest is not running distributed,
@@ -12,51 +12,51 @@ module DeepTest
     end
 
     #
-    # Before DeepTest starts any agents, it instantiates a listener and
+    # Before DeepTest starts any workers, it instantiates a listener and
     # invokes this method.  No other callbacks are made to the listener
     # instance receiving this message. 
     #
-    def before_starting_agents
+    def before_starting_workers
     end
 
     #
-    # A separate listener instance is created in each agent process and
-    # notified that the agent is starting.  The agent for the process is
-    # provided for the listener to use.  If you are using 3 agents, this
+    # A separate listener instance is created in each worker process and
+    # notified that the worker is starting.  The worker for the process is
+    # provided for the listener to use.  If you are using 3 workers, this
     # method is invoked 3 times on 3 distinct instances.  These instances
     # will also receive the starting_work and finished_work callbacks for
-    # the agent provided.
+    # the worker provided.
     #
-    def starting(agent)
+    def starting(worker)
     end
 
     #
-    # Each time a agent takes a work unit, it calls this method before
+    # Each time a worker takes a work unit, it calls this method before
     # doing the work.  In total, this method will be called as many times
     # as there are work units.  The listener instance that received the
-    # starting callback with the agent provided here is the same instance
+    # starting callback with the worker provided here is the same instance
     # that receives this message.
     #
     # Because each work processes work units in a serial fashion, the
     # listener will receive a finished_work message before another
     # starting_work message.
     #
-    def starting_work(agent, work_unit)
+    def starting_work(worker, work_unit)
     end
 
     #
-    # Each time a agent finishes computing a result for a work unit, 
+    # Each time a worker finishes computing a result for a work unit, 
     # it calls this method before sending that result back to the server.
     # In total, this method will be called as many times
     # as there are work units.  The listener instance that received the
-    # starting callback with the agent provided here is the same instance
+    # starting callback with the worker provided here is the same instance
     # that receives this message.
     #
     # Because each work processes work units in a serial fashion, the
     # listener will receive a starting_work message before another
     # finished_work message.
     #
-    def finished_work(agent, work_unit, result)
+    def finished_work(worker, work_unit, result)
     end
   end
 end

data/lib/deep_test/option.rb

@@ -0,0 +1,60 @@
+module DeepTest
+  class Option
+    attr_reader :name, :default
+
+    def initialize(name, type, default)
+      @name, @type, @default = name, type, default
+    end
+
+    def from_command_line(command_line)
+      command_line =~ /--#{name} (\S+)(\s|$)/
+      @type.from_string($1) if $1
+    end
+
+    def to_command_line(value)
+      "--#{name} #{@type.to_string(value)}" if value && value != default
+    end
+
+    module Hash
+      def self.to_string(hash)
+        pairs = []
+        hash.each do |key, value|
+          value = value.gsub(/ /,'%20') if (::String === value)
+          pairs << "#{key}:#{value.inspect}"
+        end
+        pairs.join(",")
+      end
+
+      def self.from_string(string)
+        hash = {}
+        string.split(/,/).each do |pair|
+          key, unevaled_value = pair.split(/:/)
+          value = eval(unevaled_value)
+          value = value.gsub(/%20/, " ") if ::String === value
+          hash[key.to_sym] = value
+        end
+        hash
+      end
+    end
+
+    module Integer
+      def self.to_string(i)
+        i.to_s
+      end
+
+      def self.from_string(s)
+        s.to_i
+      end
+    end
+
+    module String
+      def self.to_string(s)
+        s
+      end
+
+      def self.from_string(s)
+        s
+      end
+    end
+  end
+end