[Groonga-commit] droonga/drnbench at 4c222b6 [master] Indent

Back to archive index

YUKI Hiroshi null+****@clear*****
Thu Jan 16 16:53:36 JST 2014


YUKI Hiroshi	2014-01-16 16:53:36 +0900 (Thu, 16 Jan 2014)

  New Revision: 4c222b64f5bb22d1de64b9e1dae0757fe8152fc6
  https://github.com/droonga/drnbench/commit/4c222b64f5bb22d1de64b9e1dae0757fe8152fc6

  Message:
    Indent

  Modified files:
    lib/drnbench/shuttle/gradual-runner.rb
    lib/drnbench/shuttle/result.rb
    lib/drnbench/shuttle/runner.rb

  Modified: lib/drnbench/shuttle/gradual-runner.rb (+65 -65)
===================================================================
--- lib/drnbench/shuttle/gradual-runner.rb    2014-01-16 16:46:54 +0900 (dbb2790)
+++ lib/drnbench/shuttle/gradual-runner.rb    2014-01-16 16:53:36 +0900 (50cf827)
@@ -4,88 +4,88 @@ require "drnbench/shuttle/runner"
 require "csv"
 
 module Drnbench
-module Shuttle
-  class GradualRunner
-    attr_reader :start_n_clients, :end_n_clients, :step
-    attr_reader :report_progressively, :result
+  module Shuttle
+    class GradualRunner
+      attr_reader :start_n_clients, :end_n_clients, :step
+      attr_reader :report_progressively, :result
 
-    DEFAULT_START_N_CLIENTS = 1
-    DEFAULT_END_N_CLIENTS = 1
-    DEFAULT_STEP = 1
+      DEFAULT_START_N_CLIENTS = 1
+      DEFAULT_END_N_CLIENTS = 1
+      DEFAULT_STEP = 1
 
-    def initialize(params)
-      @start_n_clients = params[:start_n_clients] || DEFAULT_START_N_CLIENTS
-      @end_n_clients = params[:end_n_clients] || DEFAULT_END_N_CLIENTS
-      @step = params[:step] || DEFAULT_STEP
-      @report_progressively = params[:report_progressively] || false
-      @params = params
-    end
+      def initialize(params)
+        @start_n_clients = params[:start_n_clients] || DEFAULT_START_N_CLIENTS
+        @end_n_clients = params[:end_n_clients] || DEFAULT_END_N_CLIENTS
+        @step = params[:step] || DEFAULT_STEP
+        @report_progressively = params[:report_progressively] || false
+        @params = params
+      end
 
-    def run
-      run_benchmarks
-      @result
-    end
+      def run
+        run_benchmarks
+        @result
+      end
 
-    private
-    def run_benchmarks
-      @result = Result.new
-      @start_n_clients.step(@end_n_clients, @step) do |n_clients|
-        benchmark = Runner.new(@params.merge(:n_clients => n_clients))
-        if @report_progressively
-          puts "Running benchmark with #{n_clients} clients..."
-        end
-        benchmark.run
-        if @report_progressively
-          puts benchmark.result.to_s
+      private
+      def run_benchmarks
+        @result = Result.new
+        @start_n_clients.step(@end_n_clients, @step) do |n_clients|
+          benchmark = Runner.new(@params.merge(:n_clients => n_clients))
+          if @report_progressively
+            puts "Running benchmark with #{n_clients} clients..."
+          end
+          benchmark.run
+          if @report_progressively
+            puts benchmark.result.to_s
+          end
+          @result << benchmark.result
         end
-        @result << benchmark.result
       end
-    end
 
-    class Result
-      def initialize
-        @results = {}
-      end
+      class Result
+        def initialize
+          @results = {}
+        end
 
-      def <<(result)
-        @statuses = nil
-        @results[result.n_clients] = result
-      end
+        def <<(result)
+          @statuses = nil
+          @results[result.n_clients] = result
+        end
 
-      def statuses
-        @statuses ||= prepare_statuses
-      end
+        def statuses
+          @statuses ||= prepare_statuses
+        end
 
-      def to_csv
-        ([csv_header] + csv_body).collect do |row|
-          CSV.generate_line(row)
-        end.join("")
-      end
+        def to_csv
+          ([csv_header] + csv_body).collect do |row|
+            CSV.generate_line(row)
+          end.join("")
+        end
 
-      private
-      def prepare_statuses
-        statuses = []
-        @results.each do |n_clients, result|
-          statuses += result.statuses.keys
+        private
+        def prepare_statuses
+          statuses = []
+          @results.each do |n_clients, result|
+            statuses += result.statuses.keys
+          end
+          statuses.uniq!
+          statuses.sort!
+          statuses
         end
-        statuses.uniq!
-        statuses.sort!
-        statuses
-      end
 
-      def csv_header
-        Drnbench::Result.keys + statuses
-      end
+        def csv_header
+          Drnbench::Result.keys + statuses
+        end
 
-      def csv_body
-        @results.values.collect do |result|
-          result.values +
-          statuses.collect do |status|
-            result.status_percentages[status] || 0
+        def csv_body
+          @results.values.collect do |result|
+            result.values +
+            statuses.collect do |status|
+              result.status_percentages[status] || 0
+            end
           end
         end
       end
     end
   end
 end
-end

  Modified: lib/drnbench/shuttle/result.rb (+89 -89)
===================================================================
--- lib/drnbench/shuttle/result.rb    2014-01-16 16:46:54 +0900 (11a3850)
+++ lib/drnbench/shuttle/result.rb    2014-01-16 16:53:36 +0900 (a4b9ac5)
@@ -1,114 +1,114 @@
 # -*- coding: utf-8 -*-
 
 module Drnbench
-module Shuttle
-  class Result
-    attr_reader :n_clients, :duration, :statuses
-
-    class << self
-      def keys
-        [
-          :n_clients,
-          :total_n_requests,
-          :queries_per_second,
-          :min_elapsed_time,
-          :max_elapsed_time,
-          :average_elapsed_time,
-        ]
+  module Shuttle
+    class Result
+      attr_reader :n_clients, :duration, :statuses
+
+      class << self
+        def keys
+          [
+            :n_clients,
+            :total_n_requests,
+            :queries_per_second,
+            :min_elapsed_time,
+            :max_elapsed_time,
+            :average_elapsed_time,
+          ]
+        end
       end
-    end
-
-    def initialize(params)
-      @n_clients = params[:n_clients]
-      @duration = params[:duration]
-
-      @results = []
-      @total_elapsed_time = 0.0
-      @elapsed_times = []
-      @statuses = {}
-    end
 
-    def <<(result)
-      clear_cached_statistics
+      def initialize(params)
+        @n_clients = params[:n_clients]
+        @duration = params[:duration]
 
-      @results << result
+        @results = []
+        @total_elapsed_time = 0.0
+        @elapsed_times = []
+        @statuses = {}
+      end
 
-      @statuses[result[:status]] ||= 0
-      @statuses[result[:status]] += 1
+      def <<(result)
+        clear_cached_statistics
 
-      @elapsed_times << result[:elapsed_time]
-      @total_elapsed_time += result[:elapsed_time]
-    end
+        @results << result
 
-    def total_n_requests
-      @total_n_requests ||=****@resul*****
-    end
+        @statuses[result[:status]] ||= 0
+        @statuses[result[:status]] += 1
 
-    def queries_per_second
-      @queries_per_second ||= total_n_requests.to_f / @duration
-    end
+        @elapsed_times << result[:elapsed_time]
+        @total_elapsed_time += result[:elapsed_time]
+      end
 
-    def status_percentages
-      @status_percentages ||= prepare_status_percentages
-    end
+      def total_n_requests
+        @total_n_requests ||=****@resul*****
+      end
 
-    def min_elapsed_time
-      @min_elapsed_time ||= @elapsed_times.min
-    end
+      def queries_per_second
+        @queries_per_second ||= total_n_requests.to_f / @duration
+      end
 
-    def max_elapsed_time
-      @max_elapsed_time ||= @elapsed_times.min
-    end
+      def status_percentages
+        @status_percentages ||= prepare_status_percentages
+      end
 
-    def average_elapsed_time
-      @average_elapsed_time ||= @total_elapsed_time / @elapsed_times.size
-    end
+      def min_elapsed_time
+        @min_elapsed_time ||= @elapsed_times.min
+      end
 
-    def to_s
-      "Total requests: #{total_n_requests} " +
-        "(#{queries_per_second} queries per second)\n" +
-      "Status:\n" +
-      status_percentages.collect do |status, percentage|
-        "  #{status}: #{percentage} %"
-      end.join("\n") + "\n" +
-      "Elapsed time:\n" +
-      "  min:     #{min_elapsed_time} sec\n" +
-      "  max:     #{max_elapsed_time} sec\n" +
-      "  average: #{average_elapsed_time} sec"
-    end
+      def max_elapsed_time
+        @max_elapsed_time ||= @elapsed_times.min
+      end
 
-    def values
-      self.class.keys.collect do |column|
-        send(column)
+      def average_elapsed_time
+        @average_elapsed_time ||= @total_elapsed_time / @elapsed_times.size
       end
-    end
 
-    private
-    def clear_cached_statistics
-      @total_n_requests = nil
-      @queries_per_second = nil
-      @status_percentages = nil
-      @min_elapsed_time = nil
-      @max_elapsed_time = nil
-      @average_elapsed_time = nil
-    end
+      def to_s
+        "Total requests: #{total_n_requests} " +
+          "(#{queries_per_second} queries per second)\n" +
+        "Status:\n" +
+        status_percentages.collect do |status, percentage|
+          "  #{status}: #{percentage} %"
+        end.join("\n") + "\n" +
+        "Elapsed time:\n" +
+        "  min:     #{min_elapsed_time} sec\n" +
+        "  max:     #{max_elapsed_time} sec\n" +
+        "  average: #{average_elapsed_time} sec"
+      end
 
-    def prepare_status_percentages
-      status_percentages = []
-      @statuses.each do |status, n_results|
-        percentage = n_results.to_f / total_n_requests * 100
-        status_percentages << {:percentage => percentage,
-                               :status => status}
+      def values
+        self.class.keys.collect do |column|
+          send(column)
+        end
       end
-      status_percentages.sort! do |a, b|
-        (-1) * (a[:percentage] <=> b[:percentage])
+
+      private
+      def clear_cached_statistics
+        @total_n_requests = nil
+        @queries_per_second = nil
+        @status_percentages = nil
+        @min_elapsed_time = nil
+        @max_elapsed_time = nil
+        @average_elapsed_time = nil
       end
-      status_percentages = {}
-      status_percentages.each do |status|
-        status_percentages[status[:status]] = status[:percentage]
+
+      def prepare_status_percentages
+        status_percentages = []
+        @statuses.each do |status, n_results|
+          percentage = n_results.to_f / total_n_requests * 100
+          status_percentages << {:percentage => percentage,
+                                 :status => status}
+        end
+        status_percentages.sort! do |a, b|
+          (-1) * (a[:percentage] <=> b[:percentage])
+        end
+        status_percentages = {}
+        status_percentages.each do |status|
+          status_percentages[status[:status]] = status[:percentage]
+        end
+        status_percentages
       end
-      status_percentages
     end
   end
 end
-end

  Modified: lib/drnbench/shuttle/runner.rb (+87 -87)
===================================================================
--- lib/drnbench/shuttle/runner.rb    2014-01-16 16:46:54 +0900 (d340498)
+++ lib/drnbench/shuttle/runner.rb    2014-01-16 16:53:36 +0900 (b9fe6cc)
@@ -5,110 +5,110 @@ require "drnbench/client/http-droonga"
 require "drnbench/shuttle/result"
 
 module Drnbench
-module Shuttle
-  class Runner
-    attr_reader :duration, :n_clients, :result
-
-    MIN_DURATION = 1
-    DEFAULT_DURATION = 10
-    MIN_WAIT = 0
-    DEFAULT_WAIT = 1
-    DEFAULT_N_CLIENTS = 1
-    TOTAL_N_REQUESTS = 1000
-
-    def initialize(params)
-      @duration = [params[:duration] || DEFAULT_DURATION, MIN_DURATION].max
-      @n_clients = params[:n_clients] || DEFAULT_N_CLIENTS
-      @n_requests = params[:n_requests] || TOTAL_N_REQUESTS
-
-      params[:wait] ||= DEFAULT_WAIT
-      params[:wait] = [params[:wait], MIN_WAIT].max
-
-      @params = params
-
-      if params[:request_pattern]
-        params[:request_pattern][:frequency] = 1
-        @request_patterns = [params[:request_pattern]]
-      else
-        @request_patterns = params[:request_patterns]
+  module Shuttle
+    class Runner
+      attr_reader :duration, :n_clients, :result
+
+      MIN_DURATION = 1
+      DEFAULT_DURATION = 10
+      MIN_WAIT = 0
+      DEFAULT_WAIT = 1
+      DEFAULT_N_CLIENTS = 1
+      TOTAL_N_REQUESTS = 1000
+
+      def initialize(params)
+        @duration = [params[:duration] || DEFAULT_DURATION, MIN_DURATION].max
+        @n_clients = params[:n_clients] || DEFAULT_N_CLIENTS
+        @n_requests = params[:n_requests] || TOTAL_N_REQUESTS
+
+        params[:wait] ||= DEFAULT_WAIT
+        params[:wait] = [params[:wait], MIN_WAIT].max
+
+        @params = params
+
+        if params[:request_pattern]
+          params[:request_pattern][:frequency] = 1
+          @request_patterns = [params[:request_pattern]]
+        else
+          @request_patterns = params[:request_patterns]
+        end
+        populate_requests
       end
-      populate_requests
-    end
 
-    def run
-      process_requests
-      @result
-    end
+      def run
+        process_requests
+        @result
+      end
 
-    private
-    def process_requests
-      requests_queue = Queue.new
-      @result = Result.new(:n_clients => @n_clients,
-                           :duration => @duration)
-
-      client_params =****@param*****(:requests => requests_queue,
-                                    :result => @result)
-      @clients = @n_clients.times.collect do |index|
-        client = nil
-        case @params[:mode]
-        when :http
-          client = HttpClient.new(client_params)
-        when :http_droonga
-          client = HttpDroongaClient.new(client_params)
+      private
+      def process_requests
+        requests_queue = Queue.new
+        @result = Result.new(:n_clients => @n_clients,
+                             :duration => @duration)
+
+        client_params =****@param*****(:requests => requests_queue,
+                                      :result => @result)
+        @clients = @n_clients.times.collect do |index|
+          client = nil
+          case @params[:mode]
+          when :http
+            client = HttpClient.new(client_params)
+          when :http_droonga
+            client = HttpDroongaClient.new(client_params)
+          end
+          client.run
+          client
         end
-        client.run
-        client
-      end
 
-      start_time = Time.now
-      while Time.now - start_time < @duration
-        if requests_queue.empty?
-          @requests.each do |request|
-            requests_queue.push(request)
+        start_time = Time.now
+        while Time.now - start_time < @duration
+          if requests_queue.empty?
+            @requests.each do |request|
+              requests_queue.push(request)
+            end
           end
+          sleep 1
         end
-        sleep 1
-      end
 
-      @clients.each do |client|
-        client.stop
-      end
+        @clients.each do |client|
+          client.stop
+        end
 
-      @result
-    end
+        @result
+      end
 
-    def populate_requests
-      @requests = []
+      def populate_requests
+        @requests = []
 
-      if @request_patterns.is_a?(Array)
-        @request_patterns.each do |request_pattern|
-          populate_request_pattern(request_pattern)
-        end
-      else
-        @request_patterns.each do |key, request_pattern|
-          populate_request_pattern(request_pattern)
+        if @request_patterns.is_a?(Array)
+          @request_patterns.each do |request_pattern|
+            populate_request_pattern(request_pattern)
+          end
+        else
+          @request_patterns.each do |key, request_pattern|
+            populate_request_pattern(request_pattern)
+          end
         end
-      end
 
-      @requests.shuffle!
-    end
+        @requests.shuffle!
+      end
 
-    def populate_request_pattern(request_pattern)
-      frequency = request_pattern[:frequency].to_f
-      n_requests = @n_requests * frequency
+      def populate_request_pattern(request_pattern)
+        frequency = request_pattern[:frequency].to_f
+        n_requests = @n_requests * frequency
 
-      base_patterns = nil
-      if request_pattern[:pattern]
-        base_patterns = [request_pattern[:pattern]]
-      else
-        base_patterns = request_pattern[:patterns]
-      end
-      base_patterns = base_patterns.shuffle
+        base_patterns = nil
+        if request_pattern[:pattern]
+          base_patterns = [request_pattern[:pattern]]
+        else
+          base_patterns = request_pattern[:patterns]
+        end
+        base_patterns = base_patterns.shuffle
 
-      n_requests.round.times do |count|
-        @requests << base_patterns[count % base_patterns.size]
+        n_requests.round.times do |count|
+          @requests << base_patterns[count % base_patterns.size]
+        end
       end
     end
   end
 end
-end
-------------- next part --------------
HTML����������������������������...
Descargar 



More information about the Groonga-commit mailing list
Back to archive index