rubykon 0.3.0

data/benchmark/scoring.rb

@@ -0,0 +1,20 @@
+require_relative '../lib/rubykon'
+require_relative 'support/benchmark-ips'
+require_relative 'support/playout_help'
+
+Benchmark.ips do |benchmark|
+  game_9 = playout_for(9).game_state.game
+  game_13 = playout_for(13).game_state.game
+  game_19 = playout_for(19).game_state.game
+  scorer = Rubykon::GameScorer.new
+
+  benchmark.report '9x9 scoring' do
+    scorer.score game_9
+  end
+  benchmark.report '13x13 scoring' do
+    scorer.score game_13
+  end
+  benchmark.report '19x19 scoring' do
+    scorer.score game_19
+  end
+end

data/benchmark/scoring_micros.rb

@@ -0,0 +1,60 @@
+require_relative '../lib/rubykon'
+require_relative 'support/playout_help'
+require_relative 'support/benchmark-ips'
+
+class Rubykon::GameScorer
+  public :score_empty_cutting_point
+  public :find_candidate_color
+  public :only_one_color_adjacent?
+end
+
+Benchmark.ips do |benchmark|
+
+  board = Rubykon::Board.from <<-BOARD
+OOOOO-O-OOOOOOXXXXX
+O-OOOOOO-O-OOOX-X-X
+OO-OOXOXOOOO-OOXXXX
+-OOOXXXXXXOOOOOX-X-
+OOOOOXOXXXOOOOOOXXX
+OXXOOOOOXOOOO-OOOOX
+X-XOOOXXXOOOOOO-OOO
+XXXOXXXOXXOOOOOOO-O
+XX-XXXOOOOO-OOO-OOO
+X-XXXXOXXO-OOOOOOOO
+-XXXXXXXXXO-OOO-OOO
+XXXX-X-XXXXOOXOO-O-
+XX-XX-XX-XOOXXOOOOO
+-XXXXX-XXXXOX-XOOOO
+XXX-XXXXXXXXXXXXOXO
+XXXX-XXXXX-X-XXXOXO
+-XXXX-X-XXXXXXXXXXO
+X-XX-XXXX-X-XX-XOOO
+-XXXXX-XXXXXXXXXO-O
+  BOARD
+  scorer = Rubykon::GameScorer.new
+  identifier = board.identifier_for(3, 3)
+
+
+
+  benchmark.report 'score_empty_cp' do
+    game_score = {Rubykon::Board::BLACK => 0,
+                  Rubykon::Board::WHITE => Rubykon::Game::DEFAULT_KOMI}
+    scorer.score_empty_cutting_point(identifier, board, game_score)
+  end
+
+  benchmark.report 'Board#neighbour_colors_of' do
+    board.neighbour_colors_of(identifier)
+  end
+
+  neighbour_colors = board.neighbour_colors_of(identifier)
+
+  benchmark.report 'find_candidate_color' do
+    scorer.find_candidate_color(neighbour_colors)
+  end
+
+  candidate_color = scorer.find_candidate_color(neighbour_colors)
+
+  benchmark.report 'only_one_c_adj?' do
+    scorer.only_one_color_adjacent?(neighbour_colors, candidate_color)
+  end
+end

data/benchmark/support/benchmark-ips.rb

@@ -0,0 +1,11 @@
+def truffle? # truffle can't do gem install
+  defined?(RUBY_DESCRIPTION) && RUBY_DESCRIPTION.match(/graal/)
+end
+
+require 'benchmark/ips'
+
+# only loaded for truffle normally, as it has little to no effect on other
+# implementations I tested and only results in them running WAY longer.
+if truffle?
+  require_relative 'benchmark-ips_shim'
+end

data/benchmark/support/benchmark-ips_shim.rb

@@ -0,0 +1,143 @@
+# Shim modifying benchmark-ips to work better with truffle,
+# written by Chris Seaton and taken from:
+# https://gist.github.com/chrisseaton/1c4cb91f3c95ddcf2d1e
+# Note that this has very little effect on the performance of CRuby/JRuby.
+# I tried it out and results were ~2 to 4 % better which is well within
+# the tolerance. On a pre 0.3 version this moved truffle fromm 33 ips of
+# 19x19 gameplay up to 169.
+
+# This file modifies benchmark-ips to better accommodate the optimisation
+# characteristics of sophisticated implementations of Ruby that have a very
+# large difference between cold and warmed up performance, and that apply
+# optimisations such as value profiling or other speculation on runtime values.
+# Recommended to be used with a large (60s) warmup and (30s) measure time. This
+# has been modified to be the default. Note that on top of that, it now runs
+# warmup five times, so generating the report will be a lot slower than
+# before.
+
+# Code is modified from benchmark-ips
+
+# Copyright (c) 2015 Evan Phoenix
+# 
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the 'Software'), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+# 
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+module Benchmark
+  module IPS
+    class Job
+
+      def run_warmup
+        @list.each do |item|
+          @suite.warming item.label, @warmup if @suite
+
+          unless @quiet
+            $stdout.print item.label_rjust
+          end
+
+          Timing.clean_env
+
+          # Modification - run with different iteration parameters to defeat
+          # value profiling and other speculation on runtime values.
+
+          item.call_times 1
+          item.call_times 2
+          item.call_times 3
+
+          # Modification - actual time to warm up - not measured
+
+          target = Time.now + @warmup
+          while Time.now < target
+            item.call_times 1
+          end
+
+          before = Time.now
+          target = Time.now + @warmup
+
+          warmup_iter = 0
+
+          while Time.now < target
+            item.call_times(1)
+            warmup_iter += 1
+          end
+
+          after = Time.now
+
+          warmup_time_us = time_us before, after
+
+          @timing[item] = cycles_per_100ms warmup_time_us, warmup_iter
+
+          # Modification - warm up again with this new iteration value that we
+          # haven't run before.
+
+          cycles = @timing[item]
+          target = Time.now + @warmup
+
+          while Time.now < target
+            item.call_times cycles
+          end
+
+          # Modification repeat the scaling again
+
+          before = Time.now
+          target = Time.now + @warmup
+
+          warmup_iter = 0
+
+          while Time.now < target
+            item.call_times cycles
+            warmup_iter += cycles
+          end
+
+          after = Time.now
+
+          warmup_time_us = time_us before, after
+
+          @timing[item] = cycles_per_100ms warmup_time_us, warmup_iter
+
+          case Benchmark::IPS.options[:format]
+          when :human
+            $stdout.printf "%s i/100ms\n", Helpers.scale(@timing[item]) unless @quiet
+          else
+            $stdout.printf "%10d i/100ms\n", @timing[item] unless @quiet
+          end
+
+          @suite.warmup_stats warmup_time_us, @timing[item] if @suite
+
+          # Modification - warm up again with this new iteration value that we
+          # haven't run before.
+
+          cycles = @timing[item]
+          target = Time.now + @warmup
+
+          while Time.now < target
+            item.call_times cycles
+          end
+        end
+      end
+
+      alias_method :old_initialize, :initialize
+
+      def initialize opts={}
+        old_initialize opts
+        @warmup = 60
+        @time = 30
+      end
+
+    end
+  end
+end

data/benchmark/support/playout_help.rb

@@ -0,0 +1,13 @@
+def full_playout_for(size)
+  playout_object_for(size).play
+end
+
+def playout_for(size)
+  playout_object = playout_object_for(size)
+  playout_object.playout
+  playout_object
+end
+
+def playout_object_for(size)
+  MCTS::Playout.new(Rubykon::GameState.new Rubykon::Game.new(size))
+end

data/examples/mcts_laziness.rb

@@ -0,0 +1,22 @@
+require_relative '../lib/mcts'
+require_relative '../lib/mcts/examples/double_step'
+
+mcts = MCTS::MCTS.new
+
+
+[
+ {black: -4, white: 0}, {black: -3, white: 0}, {black: -2, white: 0},
+ {black: -1, white: 0}, {black: 0, white: 0}, {black: 0, white: -1},
+ {black: 0, white: -2}, {black: 0, white: -3},
+ {black: 0, white: -4}].each do |position|
+  [2, 4, 8, 10, 16, 32, 64, 100].each do |playouts|
+    results = Hash.new {0}
+    double_step_game = MCTS::Examples::DoubleStep.new position
+    10_000.times do |i|
+      root = mcts.start double_step_game, playouts
+      best_move = root.best_move
+      results[best_move] += 1
+    end
+    puts "Distribution for #{playouts} playouts with a handicap of #{position[:black] - position[:white]}: #{results}"
+  end
+end

data/exe/rubykon

@@ -0,0 +1,5 @@
+#!/usr/exe/env ruby
+require_relative '../lib/rubykon'
+
+cli = Rubykon::CLI.new
+cli.start

data/lib/benchmark/avg.rb

@@ -0,0 +1,14 @@
+require_relative 'avg/job'
+require_relative 'avg/benchmark_suite'
+
+module Benchmark
+  module Avg
+    def avg
+      benchmark_suite = BenchmarkSuite.new
+      yield benchmark_suite
+      benchmark_suite.run
+    end
+  end
+
+  extend Benchmark::Avg
+end

data/lib/benchmark/avg/benchmark_suite.rb

@@ -0,0 +1,59 @@
+# encoding: UTF-8
+module Benchmark
+  module Avg
+
+    OUTPUT_WIDTH  = 80
+    LABEL_WIDTH   = 30
+    PADDING       = 2
+    METRICS_WIDTH = OUTPUT_WIDTH - LABEL_WIDTH
+
+    class BenchmarkSuite
+
+      def initialize
+        @options = default_options
+        @jobs = []
+      end
+
+      def config(options)
+        @options.merge! options
+      end
+
+      def report(label = "", &block)
+        @jobs << Job.new(label, block)
+        self
+      end
+
+      def run
+        puts 'Running your benchmark...'
+        divider
+        each_job { |job| job.run @options[:warmup], @options[:time] }
+        puts 'Benchmarking finished, here are your reports...'
+        puts
+        puts 'Warm up results:'
+        divider
+        each_job { |job| puts job.warmup_report }
+        puts
+        puts 'Runtime results:'
+        divider
+        each_job { |job| puts job.runtime_report }
+        divider
+      end
+
+      private
+      def default_options
+        {
+          warmup: 30,
+          time: 60,
+        }
+      end
+
+      def divider
+        puts '-' * OUTPUT_WIDTH
+      end
+
+      def each_job(&proc)
+        @jobs.each &proc
+      end
+    end
+  end
+end

data/lib/benchmark/avg/job.rb

@@ -0,0 +1,92 @@
+# encoding: UTF-8
+module Benchmark
+  module Avg
+    class Job
+      PRECISION = 2
+
+      def initialize(label, block)
+        @label          = label
+        @block          = block
+        @warmup_samples = []
+        @run_samples    = []
+        @warming_up     = true
+      end
+
+      def run(warmup_time, run_time)
+        warmup_finish = Time.now + warmup_time
+        measure_until(@warmup_samples, warmup_finish)
+        finish_warmup
+
+        suite_finish = Time.now + run_time
+        measure_until(@run_samples, suite_finish)
+        finish_measure
+      end
+
+
+      def warmup_report
+        report @warmup_samples
+      end
+
+      def runtime_report
+        report @run_samples
+      end
+
+      private
+      def measure_until(samples, finish_time)
+        while Time.now < finish_time do
+          measure_block(samples)
+        end
+      end
+
+      def measure_block(samples)
+        start = Time.now
+        @block.call
+        finish = Time.now
+        samples << (finish - start)
+      end
+
+      def finish_warmup
+        @warming_up = false
+        puts "Finished warm up for #{@label}, running the real bechmarks now"
+      end
+
+      def finish_measure
+        puts "Finished measuring the run time for #{@label}"
+      end
+
+      def report(samples)
+        times   = extract_times(samples)
+        label   = @label.ljust(LABEL_WIDTH - PADDING) + padding_space
+        metrics = "#{round(times[:ipm])} i/min" << padding_space
+        metrics << "#{round(times[:avg])} s (avg)" << padding_space
+        metrics << "(± #{round(times[:standard_deviation_percent])}%)"
+        label + metrics
+      end
+
+      def round(number)
+        # not Float#round to also get numbers like 3.20 (static number after ,)
+        sprintf("%.#{PRECISION}f", number)
+      end
+
+      def padding_space
+        ' ' * PADDING
+      end
+
+      def extract_times(samples)
+        times         = {}
+        times[:total] = samples.inject(:+)
+        iterations    = samples.size
+        times[:avg]   = times[:total] / iterations
+        times[:ipm]   = iterations / (times[:total] / 60)
+        total_variane = samples.inject(0) do |total, time|
+          total + ((time - times[:avg]) ** 2)
+        end
+        times[:variance] = total_variane / iterations
+        times[:standard_deviation] = Math.sqrt times[:variance]
+        times[:standard_deviation_percent] =
+          100.0 * (times[:standard_deviation] / times[:avg])
+        times
+      end
+    end
+  end
+end