Groonga - fulltext search engine.

[Groonga-commit] droonga/fluent-plugin-droonga at ac32d34 [master] Benchmark: use "keyword" as variable name for watching keywords

YUKI Hiroshi null+****@clear*****
Mon Oct 28 15:21:34 JST 2013

• Previous message: [Groonga-commit] [Still Failing] droonga/fluent-plugin-droonga#360 (master - ce04dcf)
• Next message: [Groonga-commit] [Still Failing] droonga/fluent-plugin-droonga#361 (master - ac32d34)
• Messages sorted by: [ date ] [ thread ] [ subject ] [ author ]

YUKI Hiroshi	2013-10-28 15:21:34 +0900 (Mon, 28 Oct 2013)

  New Revision: ac32d3442ab57bdf23dcdd4d7a094aa8b0de017f
  https://github.com/droonga/fluent-plugin-droonga/commit/ac32d3442ab57bdf23dcdd4d7a094aa8b0de017f

  Message:
    Benchmark: use "keyword" as variable name for watching keywords

  Modified files:
    benchmark/utils.rb
    benchmark/watch/benchmark-notify.rb
    benchmark/watch/benchmark-scan.rb

  Modified: benchmark/utils.rb (+30 -30)
===================================================================
--- benchmark/utils.rb    2013-10-28 15:15:29 +0900 (6d12af0)
+++ benchmark/utils.rb    2013-10-28 15:21:34 +0900 (245ab7f)
@@ -38,34 +38,34 @@ module DroongaBenchmark
     end
 
 =begin
-    def subscribe_to(terms)
+    def subscribe_to(keywords)
       @context.send("load --table Query")
       @context.send("[")
-      terms.each do |term|
-        @context.send("{'_key':'#{term}'," +
-                        "'keywords':['#{term}']},")
+      keywords.each do |keyword|
+        @context.send("{'_key':'#{keyword}'," +
+                        "'keywords':['#{keyword}']},")
       end
       @context.send("]")
 
       @context.send("load --table Subscriber")
       @context.send("[")
-      terms.each do |term|
-        @context.send("{'_key':'subscriber for #{term}'," +
-                        "'subscriptions':['#{term}']," +
+      keywords.each do |keyword|
+        @context.send("{'_key':'subscriber for #{keyword}'," +
+                        "'subscriptions':['#{keyword}']," +
                         "'route':'0.0.0.0:0/benchamrk'},")
       end
       @context.send("]")
     end
 =end
 
-    def subscribe_to(terms)
+    def subscribe_to(keywords)
       queries = []
       subscribers = []
-      terms.each do |term|
-        queries << {:_key => term,
-                    :keywords => [term]}
-        subscribers << {:_key => "subscriber for #{term}",
-                        :subscriptions => [term],
+      keywords.each do |keyword|
+        queries << {:_key => keyword,
+                    :keywords => [keyword]}
+        subscribers << {:_key => "subscriber for #{keyword}",
+                        :subscriptions => [keyword],
                         :route => "0.0.0.0:0/benchamrk"}
       end
 
@@ -82,21 +82,21 @@ module DroongaBenchmark
       @context.restore(command_load_subscribers.join("\n"))
     end
 
-    def subscribe(term)
+    def subscribe(keyword)
       queries = @context["Query"]
-      query = queries.add(term, :keywords => [term])
+      query = queries.add(keyword, :keywords => [keyword])
 
       subscribers = @context["Subscriber"]
-      subscribers.add("subscriber for #{term}",
+      subscribers.add("subscriber for #{keyword}",
                       :subscriptions => [query],
                       :route => "0.0.0.0:0/benchamrk")
     end
   end
 
-  class TermsGenerator
+  class KeywordsGenerator
     class << self
-      def generate(n_terms)
-        new.generate(n_terms)
+      def generate(n_keywords)
+        new.generate(n_keywords)
       end
     end
 
@@ -104,12 +104,12 @@ module DroongaBenchmark
       @generator = to_enum(:each)
     end
 
-    def generate(n_terms)
-      terms = []
-      n_terms.times do
-        terms << @generator.next
+    def generate(n_keywords)
+      keywords = []
+      n_keywords.times do
+        keywords << @generator.next
       end
-      terms
+      keywords
     end
 
     def next
@@ -129,8 +129,8 @@ module DroongaBenchmark
 
   class TargetsGenerator
     class << self
-      def generate(n_terms, params)
-        new(params).generate(n_terms)
+      def generate(n_keywords, params)
+        new(params).generate(n_keywords)
       end
     end
 
@@ -138,7 +138,7 @@ module DroongaBenchmark
     SIZE    = 1000
 
     def initialize(params)
-      @terms     = params[:terms]
+      @keywords  = params[:keywords]
       @incidence = params[:incidence]
     end
 
@@ -149,7 +149,7 @@ module DroongaBenchmark
       n_unmatched_targets = (n_targets - n_matched_targets)
 
       n_matched_targets.times do
-        targets << generate_target(@terms.sample(1).first)
+        targets << generate_target(@keywords.sample(1).first)
       end
 
       n_unmatched_targets.times do
@@ -159,8 +159,8 @@ module DroongaBenchmark
       targets
     end
 
-    def generate_target(term="")
-     (PADDING * (SIZE / PADDING.size)) + term
+    def generate_target(keyword="")
+     (PADDING * (SIZE / PADDING.size)) + keyword
     end
   end
 end

  Modified: benchmark/watch/benchmark-notify.rb (+13 -13)
===================================================================
--- benchmark/watch/benchmark-notify.rb    2013-10-28 15:15:29 +0900 (61838b4)
+++ benchmark/watch/benchmark-notify.rb    2013-10-28 15:21:34 +0900 (dad437c)
@@ -31,35 +31,35 @@ class NotifyBenchmark
   def initialize(n_initial_subscribers)
     @database = DroongaBenchmark::WatchDatabase.new
     @watcher = Droonga::Watcher.new(@database.context)
-    @terms_generator = DroongaBenchmark::TermsGenerator.new
-    @terms = []
+    @keywords_generator = DroongaBenchmark::KeywordsGenerator.new
+    @keywords = []
     @n_subscribers = 0
     add_subscribers(n_initial_subscribers)
   end
 
   def run
-    @matched_terms.each do |term|
-      publish(term)
+    @matched_keywords.each do |keyword|
+      publish(keyword)
     end
   end
 
-  def prepare_terms(n_terms)
-    @matched_terms =****@terms*****(n_terms)
+  def prepare_keywords(n_keywords)
+    @matched_keywords =****@keywo*****(n_keywords)
   end
 
   def add_subscribers(n_subscribers)
-    new_terms = []
+    new_keywords = []
     n_subscribers.times do
-      new_terms << @terms_generator.next
+      new_keywords << @keywords_generator.next
     end
-    @database.subscribe_to(new_terms)
-    @terms += new_terms
+    @database.subscribe_to(new_keywords)
+    @keywords += new_keywords
     @n_subscribers += n_subscribers
   end
 
   private
-  def publish(matched_term)
-    @watcher.publish([matched_term], {}) do |route, subscribers|
+  def publish(matched_keyword)
+    @watcher.publish([matched_keyword], {}) do |route, subscribers|
     end
   end
 end
@@ -97,7 +97,7 @@ options[:n_steps].times do |try_count|
   notify_benchmark.add_subscribers(notify_benchmark.n_subscribers) if try_count > 0
   label = "#{notify_benchmark.n_subscribers} subscribers"
   result = Benchmark.bmbm do |benchmark|
-    notify_benchmark.prepare_terms(options[:n_times])
+    notify_benchmark.prepare_keywords(options[:n_times])
     benchmark.report(label) do
       notify_benchmark.run
     end

  Modified: benchmark/watch/benchmark-scan.rb (+21 -21)
===================================================================
--- benchmark/watch/benchmark-scan.rb    2013-10-28 15:15:29 +0900 (aa5967c)
+++ benchmark/watch/benchmark-scan.rb    2013-10-28 15:21:34 +0900 (1d7bd7f)
@@ -26,7 +26,7 @@ require "droonga/watcher"
 require File.expand_path(File.join(__FILE__, "..", "..", "utils.rb"))
 
 class ScanBenchmark
-  attr_reader :n_terms
+  attr_reader :n_keywords
 
   def initialize(n_times, incidence=0)
     @n_times = n_times
@@ -36,12 +36,12 @@ class ScanBenchmark
 
     @watcher = Droonga::Watcher.new(@database.context)
 
-    @terms_generator = DroongaBenchmark::TermsGenerator.new
-    @terms = @terms_generator.generate(@n_times)
+    @keywords_generator = DroongaBenchmark::KeywordsGenerator.new
+    @keywords = @keywords_generator.generate(@n_times)
     prepare_targets(@incidence)
 
-    @database.subscribe_to(@terms)
-    @n_terms =****@terms*****
+    @database.subscribe_to(@keywords)
+    @n_keywords =****@keywo*****
 
     @hits = []
   end
@@ -55,18 +55,18 @@ class ScanBenchmark
   def prepare_targets(incidence=0)
     @incidence = incidence
     @targets = DroongaBenchmark::TargetsGenerator.generate(@n_times,
-                                                           :terms => @terms.sample(@n_times),
+                                                           :keywords => @keywords.sample(@n_times),
                                                            :incidence => @incidence)
   end
 
-  def add_terms(n_terms)
-    new_terms = []
-    n_terms.times do
-      new_terms << @terms_generator.next
+  def add_keywords(n_keywords)
+    new_keywords = []
+    n_keywords.times do
+      new_keywords << @keywords_generator.next
     end
-    @database.subscribe_to(new_terms)
-    @terms += new_terms
-    @n_terms += n_terms
+    @database.subscribe_to(new_keywords)
+    @keywords += new_keywords
+    @n_keywords += n_keywords
   end
 
   private
@@ -77,15 +77,15 @@ class ScanBenchmark
 end
 
 options = {
-  :n_watching_terms => 1000,
+  :n_watching_keywords => 1000,
   :n_steps          => 10,
   :incidences       => "0.1,0.5,0.9",
   :output_path      => "/tmp/watch-benchmark-scan.csv",
 }
 option_parser = OptionParser.new do |parser|
-  parser.on("--terms=N", Integer,
-            "number of watching terms (optional)") do |n_watching_terms|
-    options[:n_watching_terms] = n_watching_terms
+  parser.on("--keywords=N", Integer,
+            "number of watching keywords (optional)") do |n_watching_keywords|
+    options[:n_watching_keywords] = n_watching_keywords
   end
   parser.on("--steps=N", Integer,
             "number of benchmark steps (optional)") do |n_steps|
@@ -104,13 +104,13 @@ args = option_parser.parse!(ARGV)
 
 
 results_by_incidence = {}
-scan_benchmark = ScanBenchmark.new(options[:n_watching_terms])
+scan_benchmark = ScanBenchmark.new(options[:n_watching_keywords])
 options[:n_steps].times do |try_count|
-  scan_benchmark.add_terms(scan_benchmark.n_terms) if try_count > 0
-  puts "\n=============== #{scan_benchmark.n_terms} keywords ===============\n"
+  scan_benchmark.add_keywords(scan_benchmark.n_keywords) if try_count > 0
+  puts "\n=============== #{scan_benchmark.n_keywords} keywords ===============\n"
   options[:incidences].split(/[,\s]+/).each do |incidence|
     results_by_incidence[incidence] ||= []
-    label = "incidence #{incidence}/#{scan_benchmark.n_terms} keywords"
+    label = "incidence #{incidence}/#{scan_benchmark.n_keywords} keywords"
     result = Benchmark.bmbm do |benchmark|
       puts "\n>>>>> targets for #{incidence}\n"
       scan_benchmark.prepare_targets(incidence.to_f)
-------------- next part --------------
HTML����������������������������...
Download 

• Previous message: [Groonga-commit] [Still Failing] droonga/fluent-plugin-droonga#360 (master - ce04dcf)
• Next message: [Groonga-commit] [Still Failing] droonga/fluent-plugin-droonga#361 (master - ac32d34)
• Messages sorted by: [ date ] [ thread ] [ subject ] [ author ]