drnbench 1.0.3 → 1.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3b10736f18dbeaf958fe4b9bd29c0a6788b69f3c
-  data.tar.gz: bc4363d42fd30a955a70f4d2241052486e121635
+  metadata.gz: 6f1ededc12c542fd3d9cdd9f908e3488aa4e4e22
+  data.tar.gz: 6c42a7d169c1880cc272e3d652c4cfabe532432b
 SHA512:
-  metadata.gz: c7d68baea7789ca3a4a803fa7a4b5d2ff3c24252a7cf49c89d0f33a5eb598f9c0f064dc64c6eb35251abe6a0de4fe910d554e562a5151e18eb00d43973e3ea37
-  data.tar.gz: 4dad01b34e627c89618827e67f2f070c6cdb229f208d65214361b76477b6d91b10f6be69bf62ed2695078356341714f64fd4007277e674a8f8f8f3a0f4d8f527
+  metadata.gz: c611caff29de7e18bee469d17501a6a24570fdb68a464c9d53c2a6e6bf42471d2406f69c52c70f43f340aa99f62f8f946b28fccd92a3625113870344ceba229a
+  data.tar.gz: edd62ed000afc56ea5feb077597859efdbd8026a5f37d75f6137fa0ae6c4c94d8acbcc1c0358ebedbaa91bdcfd9fe55a3b637433d0b77d6c15cda68b99324146

data/bin/drnbench-publish-subscribe

@@ -19,6 +19,7 @@
 require "drnbench"
 require "optparse"
 require "shellwords"
+require "sigdump/setup"
 
 config = Drnbench::PublishSubscribe::Configuration.new
 option_parser = OptionParser.new do |parser|

data/bin/drnbench-request-response

@@ -18,6 +18,7 @@
 
 require "drnbench"
 require "optparse"
+require "sigdump/setup"
 
 config = Drnbench::RequestResponse::Configuration.new
 option_parser = OptionParser.new do |parser|
@@ -39,6 +40,11 @@ option_parser = OptionParser.new do |parser|
             "(#{config.n_slow_requests})") do |n_slow_requests|
     config.n_slow_requests = n_slow_requests
   end
+  parser.on("--n-fast-requests=N", Integer,
+            "Number of fast requests to be reported.",
+            "(#{config.n_fast_requests})") do |n_fast_requests|
+    config.n_fast_requests = n_fast_requests
+  end
 
   parser.separator("")
   parser.separator("Progressive benchmark:")

data/doc/text/news.md

@@ -1,6 +1,15 @@
 # News
 
-## 1.0.3: 2014-10-29 (planned)
+## 1.0.4: 2014-11-29
+
+ * `drnbench-request-response`
+   * Not only top slow requests, but top fast requests are also reported.
+     It will help you to detect "strange good" results from invalid queries or something.
+     The number of reported fast requests can be customized via the new `--n-fast-requests` option.
+   * Virtual clients are working with multiple processes.
+     If there are multiple processors in your computer, drnbench uses them more effectively.
+
+## 1.0.3: 2014-10-07
 
  * `drnbench-request-response`
    * Accept multiple hosts as a comma separated list via the `--default-hosts` option.

data/drnbench.gemspec

@@ -51,6 +51,8 @@ Gem::Specification.new do |spec|
   spec.add_runtime_dependency("json")
   spec.add_runtime_dependency("droonga-client")
   spec.add_runtime_dependency("drntest")
+  spec.add_runtime_dependency("facter")
+  spec.add_runtime_dependency("sigdump")
 
   spec.add_development_dependency("bundler")
   spec.add_development_dependency("rake")

data/lib/drnbench/client/http-droonga.rb

@@ -19,9 +19,9 @@ module Drnbench
     DEFAULT_COMMAND   = "search"
     DEFAULT_METHOD    = "POST"
 
-    def initialize(params, config)
+    def initialize(params)
       super
-      @command = params["command"] || DEFAULT_COMMAND
+      @command = params[:command] || DEFAULT_COMMAND
     end
 
     private

data/lib/drnbench/client/http.rb

@@ -16,59 +16,68 @@
 require "thread"
 require "droonga/client"
 require "json"
+require "drb"
 
 module Drnbench
   class HttpClient
-    attr_reader :requests, :results, :wait
+    attr_reader :runner, :results, :wait
 
     SUPPORTED_HTTP_METHODS = ["GET", "POST"]
 
     @@count = 0
 
-    def initialize(params, config)
-      @requests = params[:requests]
-      @result   = params[:result]
-      @config   = config
+    def initialize(params)
+      @runner   = params[:runner]
+      @config   = params[:config]
       @count    = 0
       @id       = @@count
       @@count += 1
+      @thread = nil
     end
 
     def run
       @thread = Thread.new do
+        clients = {}
+        start_time = Time.now
         loop do
-          request = @requests.pop
+          if @runner.empty?
+            puts "WORNING: requests queue becomes empty! (#{Time.now - start_time} sec)"
+            stop
+            break
+          end
+
+          request = @runner.pop_request
           request = fixup_request(request)
 
-          client = Droonga::Client.new(:protocol => :http,
-                                       :host => request["host"],
-                                       :port => request["port"],
-                                       :timeout => request["timeout"])
+          client_params = {
+            :protocol => :http,
+            :host     => request["host"],
+            :port     => request["port"],
+            :timeout  => request["timeout"],
+          }
+          client = clients[client_params.to_s] ||= Droonga::Client.new(client_params)
+
           request["headers"] ||= {}
           request["headers"]["user-agent"] = "Ruby/#{RUBY_VERSION} Droonga::Benchmark::Runner::HttpClient"
           start_time = Time.now
-          @last_request = request
-          @last_start_time = start_time
           begin
           response = client.request(request)
-            @result << {
+            @runner.push_result(
               :request => request,
               :status => response.code,
               :elapsed_time => Time.now - start_time,
               :client => @id,
               :index => @count,
-            }
+            )
           rescue Timeout::Error
-            @result << {
+            @runner.push_result(
               :request => request,
               :status => "0",
               :elapsed_time => Time.now - start_time,
               :client => @id,
               :index => @count,
-            }
+            )
           end
-          @last_request = nil
-          @last_start_time = nil
           @count += 1
           sleep @config.wait
         end
@@ -77,18 +86,14 @@ module Drnbench
     end
 
     def stop
+      return unless @thread
+
       @thread.exit
+      @thread = nil
+    end
 
-      if @last_request
-        @result << {
-          :request => @last_request,
-          :status => "0",
-          :elapsed_time => Time.now - @last_start_time,
-          :client => @id,
-          :index => @count,
-          :last => true,
-        }
-      end
+    def running?
+      not @thread.nil?
     end
 
     private

data/lib/drnbench/request-response/configuration.rb

@@ -19,7 +19,8 @@ module Drnbench
   module RequestResponse
     class Configuration
       attr_accessor :duration, :wait, :interval, :request_patterns_file
-      attr_accessor :start_n_clients, :end_n_clients, :step, :n_requests, :n_slow_requests
+      attr_accessor :start_n_clients, :end_n_clients, :step, :n_requests
+      attr_accessor :n_slow_requests, :n_fast_requests
       attr_accessor :mode
       attr_reader   :default_hosts
       attr_accessor :default_port, :default_path, :default_method, :default_timeout
@@ -38,6 +39,7 @@ module Drnbench
         @n_requests           = 1000
         @mode                 = :http
         @n_slow_requests      = 5
+        @n_fast_requests      = 5
 
         @default_hosts        = ["localhost"]
         @default_port         = 80

data/lib/drnbench/request-response/request-pattern.rb

@@ -66,9 +66,17 @@ module Drnbench
           groups.each do |group|
             n_requests = @config.n_requests * @config.end_n_clients * group.frequency
             base_patterns = group.patterns.shuffle
-            n_requests.round.times do |count|
+            n_requests.ceil.times do |count|
               pattern = base_patterns[count % base_patterns.size]
-              requests << pattern.to_request
+              if @config.default_hosts.size > 1
+                @config.default_hosts.each do |host|
+                  request = pattern.to_request
+                  request["host"] ||= host
+                  requests << request
+                end
+              else
+                requests << pattern.to_request
+              end
             end
           end
           requests
@@ -172,11 +180,6 @@ module Drnbench
         end
 
         def to_request
-          @populated ||= populate
-        end
-
-        private
-        def populate
           if @source.is_a?(String)
             request = { "path" => @source }
           else

data/lib/drnbench/request-response/result.rb

@@ -16,7 +16,7 @@
 module Drnbench
   module RequestResponse
     class Result
-      attr_reader :n_clients, :statuses, :n_slow_requests
+      attr_reader :n_clients, :statuses, :n_slow_requests, :n_fast_requests
       attr_accessor :duration
 
       class << self
@@ -36,6 +36,7 @@ module Drnbench
         @n_clients = params[:n_clients]
         @duration = params[:duration]
         @n_slow_requests = params[:n_slow_requests] || 5
+        @n_fast_requests = params[:n_fast_requests] || 5
 
         @results = []
         @total_elapsed_time = 0.0
@@ -44,6 +45,10 @@ module Drnbench
       end
 
       def <<(result)
+        push(result)
+      end
+
+      def push(result)
         clear_cached_statistics
 
         @results << result
@@ -85,21 +90,31 @@ module Drnbench
 
       def top_slow_requests
         slow_requests[0..@n_slow_requests-1].collect do |result|
-          request = result[:request]
-          status = result[:status].to_i
-          if status.zero?
-            status = "#{status}(aborted)"
-          end
-          index = result[:index]
-          index = "#{index}(last)" if result[:last]
-          [
-            "#{result[:elapsed_time]} sec:",
-            request["method"],
-            status,
-            "<#{result[:client]}>#{index}",
-            "http://#{request["host"]}:#{request["port"]}#{request["path"]}",
-          ].join(" ")
+          format_result_for_request_line(result)
+        end
+      end
+
+      def top_fast_requests
+        fast_requests[0..@n_fast_requests-1].collect do |result|
+          format_result_for_request_line(result)
+        end
+      end
+
+      def format_result_for_request_line(result)
+        request = result[:request]
+        status = result[:status].to_i
+        if status.zero?
+          status = "#{status}(aborted)"
         end
+        index = result[:index]
+        index = "#{index}(last)" if result[:last]
+        [
+          "#{result[:elapsed_time]} sec:",
+          request["method"],
+          status,
+          "<#{result[:client]}>#{index}",
+          "http://#{request["host"]}:#{request["port"]}#{request["path"]}",
+        ].join(" ")
       end
 
       def slow_requests
@@ -108,6 +123,12 @@ module Drnbench
         end
       end
 
+      def fast_requests
+        @results.sort do |a, b|
+          a[:elapsed_time] <=> b[:elapsed_time]
+        end
+      end
+
       def to_s
         "Total requests: #{total_n_requests} " +
           "(#{queries_per_second} queries per second)\n" +
@@ -119,6 +140,11 @@ module Drnbench
         "  min:     #{min_elapsed_time} sec\n" +
         "  max:     #{max_elapsed_time} sec\n" +
         "  average: #{average_elapsed_time} sec\n" +
+        "Top #{@n_fast_requests} fast requests:\n" +
+        " [time: method status <client>index url]\n" +
+        top_fast_requests.collect do |request|
+          "  #{request}"
+        end.join("\n") + "\n" +
         "Top #{@n_slow_requests} slow requests:\n" +
         " [time: method status <client>index url]\n" +
         top_slow_requests.collect do |request|

data/lib/drnbench/request-response/runner.rb

@@ -13,6 +13,7 @@
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
+require "facter"
 require "drnbench/client/http"
 require "drnbench/client/http-droonga"
 require "drnbench/request-response/result"
@@ -23,6 +24,10 @@ module Drnbench
     class Runner
       attr_reader :n_clients, :result
 
+      MESSAGE_EXIT     = "exit"
+      MESSAGE_START    = "start"
+      MESSAGE_COMPLETE = "complete"
+
       def initialize(n_clients, config)
         n_clients = 1 if n_clients.zero?
         @n_clients = n_clients
@@ -37,50 +42,185 @@ module Drnbench
         @result
       end
 
+      def pop_request
+        @requests.pop
+      end
+
+      def push_result(result)
+        @result << result
+      end
+
+      def empty?
+        @requests.empty?
+      end
+
       private
       def process_requests
+        @result = Result.new(:n_clients => @n_clients,
+                             :duration => @config.duration,
+                             :n_fast_requests => @config.n_fast_requests,
+                             :n_slow_requests => @config.n_slow_requests)
+
+        setup_child_processes
+        initiate_child_processes
+        wait_for_given_duration
+        kill_child_processes
+
+        @result
+      end
+
+      def setup_child_processes
+        @child_processes = []
+        @total_n_clients = 0
+        n_processes.times.each do |index|
+          setup_child_process
+        end
+      end
+
+      def setup_child_process
+        n_clients = n_clients_per_process
+        if @total_n_clients + n_clients > @n_clients
+          n_clients = @n_clients - @total_n_clients
+        end
+        return if n_clients <= 0
+
+        # Prepare request queue for child process at first
+        # to reduce needless inter-process communications (IPC) while running!
         requests_queue = Queue.new
-        @requests.each do |request|
+        @requests.slice!(0..n_requests_per_process).each do |request|
           requests_queue.push(request)
         end
 
-        @result = Result.new(:n_clients => @n_clients,
-                             :duration => @config.duration,
-                             :n_slow_requests => @config.n_slow_requests)
+        parent_read, child_write = IO.pipe
+        child_read, parent_write = IO.pipe
+
+        pid = fork do
+
+          parent_write.close
+          parent_read.close
+          druby_uri = child_read.gets.chomp
+          @parent = DRbObject.new_with_uri(druby_uri)
+
+          @requests = requests_queue
+          @result = []
+
+          # Because continuous benchmark increases objects,
+          # GC painflly slows down the process.
+          GC.start
+          GC.disable
 
-        client_params = {
-          :requests => requests_queue,
-          :result   => @result,
+          clients = setup_clients(n_clients)
+
+          loop do
+            message = child_read.gets
+            if message and message.chomp == MESSAGE_EXIT
+              clients.each(&:stop)
+              # We also should reduce IPC for results.
+              @result.each do |result|
+                @parent.push_result(result)
+              end
+              child_write.puts(MESSAGE_COMPLETE)
+              child_write.close
+              exit!
+            end
+            sleep(3)
+          end
+        end
+        @child_processes << {
+          :pid    => pid,
+          :input  => parent_read,
+          :output => parent_write,
         }
-        @clients = @n_clients.times.collect do |index|
-          client = nil
+
+        requests_queue = nil
+
+        child_read.close
+        child_write.close
+      end
+
+      def setup_clients(count)
+        count.times.collect do |index|
           case @config.mode
           when :http
-            client = HttpClient.new(client_params, @config)
+            client = HttpClient.new(:runner => self,
+                                    :config => @config)
           when :http_droonga
-            client = HttpDroongaClient.new(client_params, @config)
+            client = HttpDroongaClient.new(:runner => self,
+                                           :config => @config)
           else
             raise ArgumentError.new("Unknown mode: #{@config.mode}")
           end
           client.run
           client
         end
+      end
+
+      def initiate_child_processes
+        DRb.start_service("druby://localhost:0", self)
+        @child_processes.each do |child|
+          child[:output].puts(DRb.uri)
+        end
+      end
 
+      ONE_MINUTE_IN_SECONDS = 60
+      ONE_HOUR_IN_SECONDS = ONE_MINUTE_IN_SECONDS * 60
+
+      def wait_for_given_duration
         start_time = Time.now
-        while Time.now - start_time < @config.duration
+        last_message = ""
+        loop do
           sleep 1
-          if requests_queue.empty?
-            puts "WORNING: requests queue becomes empty! (#{Time.now - start_time} sec)"
-            @result.duration = Time.now - start_time
-            break
-          end
+          elapsed_time = (Time.now - start_time).to_i
+          break if elapsed_time >= @config.duration
+
+          remaining_seconds  = @config.duration - elapsed_time
+          remaining_hours    = (remaining_seconds / ONE_HOUR_IN_SECONDS).floor
+          remaining_seconds -= remaining_hours * ONE_HOUR_IN_SECONDS
+          remaining_minutes  = (remaining_seconds / ONE_MINUTE_IN_SECONDS).floor
+          remaining_seconds -= remaining_minutes * ONE_MINUTE_IN_SECONDS
+          remaining_time     = sprintf("%02i:%02i:%02i", remaining_hours, remaining_minutes, remaining_seconds)
+          next_message = "#{remaining_time} remaining..."
+          printf("%s", "#{" " * last_message.size}\r")
+          printf("%s", "#{next_message}\r")
+          last_message = next_message
         end
+      end
+
+      def kill_child_processes
+        puts "Collecting results..."
 
-        @clients.each do |client|
-          client.stop
+        @child_processes.each do |child|
+          child[:output].puts(MESSAGE_EXIT)
         end
 
-        @result
+        loop do
+          @child_processes = @child_processes.reject do |child|
+            message = child[:input].gets
+            if message and message.chomp == MESSAGE_COMPLETE
+              Process.detach(child[:pid])
+              true
+            else
+              false
+            end
+          end
+          break if @child_processes.empty?
+        end
+      end
+
+      def n_processes
+        [[@n_clients, 1].max, max_n_processes].min
+      end
+
+      def max_n_processes
+        Facter["processorcount"].value.to_i
+      end
+
+      def n_clients_per_process
+        (@n_clients.to_f / n_processes).ceil
+      end
+
+      def n_requests_per_process
+        (@requests.size.to_f / n_processes).round
       end
     end
   end

data/lib/drnbench/version.rb

@@ -14,5 +14,5 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 module Drnbench
-  VERSION = "1.0.3"
+  VERSION = "1.0.4"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: drnbench
 version: !ruby/object:Gem::Version
-  version: 1.0.3
+  version: 1.0.4
 platform: ruby
 authors:
 - YUKI Hiroshi
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-10-07 00:00:00.000000000 Z
+date: 2014-11-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
@@ -53,6 +53,34 @@ dependencies:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: facter
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sigdump
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement