redshift 1.3.15

data/bench/bench

@@ -0,0 +1,26 @@
+#!/usr/bin/env ruby
+
+def bench_one(name)
+  lib = File.join(File.dirname(__FILE__), name)
+  cmd = %{
+    $REDSHIFT_CLIB_NAME = "#{name}"
+    puts "#{name}:"
+    #{name.split(/[-_]/).map {|w|w.capitalize}.join}.do_bench {|l| puts l}
+  }
+  system "ruby", "-r" , "./bench", "-r", lib, "-e", cmd
+end
+
+pat = ARGV.pop
+pat = pat ? Regexp.new(pat) : //
+%w{
+  alg-state
+  continuous
+  discrete
+  euler
+  formula
+  half-strict
+  inertness
+  queue
+}.grep(pat).each do |name|
+  bench_one(name)
+end

data/bench/bench.rb

@@ -0,0 +1,10 @@
+def bench
+  times = Process.times
+  t0 = times.utime #+ times.stime
+
+  yield
+
+  times = Process.times
+  t1 = times.utime #+ times.stime
+  t1 - t0
+end

data/bench/continuous.rb

@@ -0,0 +1,76 @@
+# Measures performance of redshift as a pure integrator.
+#
+# Formulas are minimal to factor out C library time.
+
+require 'redshift'
+
+include RedShift
+
+module Continuous
+  class C < Component
+    strictly_continuous :x, :y
+    flow do
+      diff " x' =   y "
+      diff " y' =  -x "
+    end
+  end
+  
+  def self.make_world n=1
+    w = World.new
+    n.times do
+      w.create(C) do |c|
+        c.x = 0.0
+        c.y = 1.0
+      end
+    end
+    w
+  end
+
+  def self.do_bench
+    [ [       1, 1_000_000],
+      [      10,   100_000],
+      [     100,    10_000],
+      [   1_000,     1_000],
+      [  10_000,       100],
+      [ 100_000,        10] ].each do
+      |     n_c,     n_s|
+      
+      w = make_world(n_c)
+      w.run 1 # warm up
+      r = bench do
+        w.run(n_s)
+      end
+      
+      yield "  - %10d comps X %10d steps: %8.2f" % [n_c, n_s, r]
+    end
+  end
+end
+
+if __FILE__ == $0
+
+  require 'bench'
+  w = Continuous.make_world(1000)
+  time = bench do
+    w.run(1000)
+  end
+  p time
+
+exit
+  require File.join(File.dirname(__FILE__), 'bench')
+  puts "continuous:"
+  Continuous.do_bench {|l| puts l}
+#  puts "continuous:", (1..3).map {Continuous.do_bench}
+  
+  if false
+    require 'ruby-prof'
+
+    w = Continuous.make_world(10_000)
+    result = RubyProf.profile do
+      w.run(10)
+    end
+
+    printer = RubyProf::GraphPrinter.new(result)
+    printer.print(STDOUT, 0)
+  end
+end
+

data/bench/diff-bench

@@ -0,0 +1,86 @@
+#!/usr/bin/env ruby
+
+require 'yaml'
+require 'argos'
+require 'object-diff'
+
+defaults = {
+  "d"   => 0.01
+}
+optdef = {
+  "d"   => proc {|d| Float(d)}
+}
+opts = defaults.merge(Argos.parse_options(ARGV, optdef))
+
+case ARGV.size
+when 2
+  b0, b1 = [0,1].map {|i| YAML.load(File.read(ARGV[i]))}
+when 1
+  b0 = YAML.load(File.read(ARGV[0]))
+  b1 = YAML.load($stdin.read)
+end
+
+module Enumerable
+  def show_results depth=0
+    if size > 1 and depth > 0
+      puts
+      depth*2
+    elsif size == 1 and (first_value.size rescue 0) == 1
+      puts
+      depth*2
+    else
+      0
+    end
+  end
+end
+
+class Hash
+  def first_value
+    values.first
+  end
+  
+  def show_results depth=0
+    indent = super
+
+    keys.sort.each do |key|
+      val = self[key]
+      case val
+      when Numeric
+        printf "%#{indent}s%#{64-indent}s: %+8.2f\n", "", key, val
+      else
+        printf "%#{indent}s: ", key
+        val.show_results depth + 1
+      end
+    end
+  end
+end
+
+class Array
+  def first_value
+    first
+  end
+  
+  def show_results depth=0
+    indent = super
+    
+    each do |val|
+      case val
+      when Numeric
+        printf "%#{indent}s- %+8.2f\n", "", val
+      else
+        printf "%#{indent}s- ", ""
+        val.show_results depth + 1
+      end
+    end
+  end
+end
+
+class Numeric
+  def diff other
+    super / to_f
+  end
+end
+
+d_min = opts["d"]
+diffs = b0.diff(b1).filter {|d| d.abs >= d_min}
+diffs.show_results

data/bench/discrete.rb

@@ -0,0 +1,101 @@
+# Measures performance of redshift for pure discrete event simulation.
+# See also the queue.rb benchmark.
+
+require 'redshift'
+
+include RedShift
+
+module Discrete
+  class Clock < Component
+    # the only continuous var in the whole system
+    strictly_continuous :time
+    flow {
+      diff " time' = 1 "
+    }
+  end
+  
+  class Awakener < Component
+    export :awake
+  end
+  
+  class Sleeper < Awakener
+    strict_link :clock => Clock
+    
+    constant :next_wakeup
+    strictly_constant :period
+    
+    setup do
+      self.next_wakeup = period
+    end
+    
+    transition do
+      guard " clock.time >= next_wakeup "
+      reset :next_wakeup => " clock.time + period "
+        ## need something between strict and not:
+        ## only changes at end of discrete update, and so
+        ## strictness optimizations still apply
+      event :awake
+    end
+  end
+  
+  class Watcher < Awakener
+    link :target => Awakener
+    transition do
+      sync :target => :awake
+      event :awake
+    end
+  end
+  
+  def self.make_world n_sleeper=1, n_watchers=0
+    w = World.new
+    clock = w.create(Clock)
+    n_sleeper.times do |i|
+      sleeper = w.create(Sleeper) do |c|
+        c.clock = clock
+        c.period = ((i % 99)+1) / 10.0
+      end
+      target = sleeper
+      n_watchers.times do
+        target = w.create(Watcher) do |c|
+          c.target = target
+        end
+      end
+    end
+    w
+  end
+
+  def self.do_bench
+    [0, 1, 5].each do |n_w|
+      [ [       1, 1_000_000   ],
+        [      10,   100_000   ],
+        [     100,    10_000   ],
+        [   1_000,     1_000   ],
+        [  10_000,       100   ],
+        [ 100_000,        10   ] ].each do
+        |     n_c,       n_s|
+        if n_w > 1
+          do_bench_one(n_c, n_s/n_w, n_w) {|r| yield r}
+        else
+          do_bench_one(n_c, n_s, n_w) {|r| yield r}
+        end
+      end
+    end
+  end
+  
+  def self.do_bench_one(n_c, n_s, n_w)
+    w = make_world(n_c, n_w)
+    r = bench do
+      w.run(n_s)
+    end
+
+    yield "  - %10d comps X %10d steps X %5d watchers: %8.2f" %
+      [n_c, n_s, n_w, r]
+  end
+end
+
+if __FILE__ == $0
+  require File.join(File.dirname(__FILE__), 'bench')
+  puts "discrete:"
+  Discrete.do_bench_one(100, 5_000, 5) {|l| puts l}
+end
+

data/bench/euler.rb

@@ -0,0 +1,50 @@
+# Measures performance of Euler integration.
+
+require 'redshift'
+
+include RedShift
+
+module Euler
+  class Flow_Euler < Component
+    flow do
+      euler "x' = 1"
+      euler "y' = x" # Very bad!
+    end
+  end
+  
+  def self.make_world n=1
+    w = World.new
+    n.times do
+      w.create(Flow_Euler)
+    end
+    w
+  end
+
+  def self.do_bench
+    [ [       1, 1_000_000],
+      [      10,   100_000],
+      [     100,    10_000],
+      [   1_000,     1_000],
+      [  10_000,       100],
+      [ 100_000,        10] ].each do
+      |     n_c,     n_s|
+      
+      w = make_world(n_c)
+      w.run 1 # warm up
+      r = bench do
+        w.run(n_s)
+      end
+      
+      yield "  - %10d comps X %10d steps: %8.2f" % [n_c, n_s, r]
+    end
+  end
+end
+
+if __FILE__ == $0
+  require 'bench'
+  w = Euler.make_world(1000)
+  time = bench do
+    w.run(1000)
+  end
+  p time
+end

data/bench/formula.rb

@@ -0,0 +1,78 @@
+# Measures performance of redshift as a pure integrator.
+# using more complex formulas than in continuous.rb.
+
+# Try replacing
+#   CFLAGS   =  -fPIC -g -O2 
+# with
+#   CFLAGS   = -fPIC -O2 -march=i686 -msse2 -mfpmath=sse
+
+case RUBY_PLATFORM
+when /x86_64/
+  $CFLAGS="-fPIC -O2 -march=k8 -msse2 -mfpmath=sse"
+else
+  $CFLAGS="-fPIC -O2 -march=i686 -msse2 -mfpmath=sse"
+end
+
+require 'redshift'
+
+include RedShift
+
+module Formula
+  class C < Component
+    strictly_continuous :x, :y
+    flow do
+      diff " x' =   pow(y,3) + sqrt(fabs(sin(y))) "
+      diff " y' =  -x "
+    end
+  end
+  
+  def self.make_world n=1
+    w = World.new
+    n.times do
+      w.create(C) do |c|
+        c.x = 0.0
+        c.y = 1.0
+      end
+    end
+    w
+  end
+
+  def self.do_bench
+    [ [       1, 100_000],
+      [      10,  10_000],
+      [     100,   1_000],
+      [   1_000,     100],
+      [  10_000,      10] ].each do
+      |     n_c,     n_s|
+      
+      w = make_world(n_c)
+      w.run 1 # warm up
+      r = bench do
+        w.run(n_s)
+      end
+      
+      yield "  - %10d comps X %10d steps: %8.2f" % [n_c, n_s, r]
+    end
+  end
+end
+
+if __FILE__ == $0
+
+  require File.join(File.dirname(__FILE__), 'bench')
+  puts "continuous:"
+  Formula.do_bench {|l| puts l}
+  
+  if false
+    require 'ruby-prof'
+
+    w = Formula.make_world(10_000)
+    result = RubyProf.profile do
+      w.run(10)
+    end
+
+    printer = RubyProf::GraphPrinter.new(result)
+    printer.print(STDOUT, 0)
+  end
+
+end
+

data/bench/half-strict.rb

@@ -0,0 +1,103 @@
+# Measures benefit of optimizing the case in which only some of the outgoing
+# transitions are strict.
+
+require 'redshift'
+require 'enumerator'
+
+include RedShift
+
+module HalfStrict
+  class Clock < Component
+    # the only continuous var in the whole system
+    strictly_continuous :t_strict
+    flow {
+      diff " t_strict' = 1 "
+      diff " t' = 1 "
+    }
+  end
+  
+  class Observer < Component
+    strict_link :clock => Clock
+    
+    transition do
+      guard " clock.t_strict < 0 "
+    end
+    transition do
+      guard " clock.t_strict < 0 "
+    end
+    transition do
+      guard " clock.t_strict < 0 "
+    end
+    transition do
+      guard " clock.t_strict < 0 "
+    end
+    transition do
+      guard " clock.t_strict < 0 "
+    end
+
+    transition do
+      guard " clock.t < 0 "
+    end
+  end
+  
+  class Dummy < Component
+    n_states = 10
+    my_states = state((0...n_states).map {|i| "S#{i}"})
+    start S0
+    
+    flow S0 do
+      diff " t' = 1 "
+    end
+    
+    transition S0 => S1 do
+      guard "t > 0"
+      reset :t => 0
+    end
+
+    my_states[1..-1].each_cons(2) do |s, t|
+      transition s => t
+    end
+    transition my_states.last => my_states.first
+  end
+
+  def self.make_world n_observers=1
+    w = World.new
+    w.create(Dummy)
+    clock = w.create(Clock)
+    n_observers.times do |i|
+      observer = w.create(Observer) do |c|
+        c.clock = clock
+      end
+    end
+    w
+  end
+
+  def self.do_bench
+    [ [      10,   100_000   ],
+      [     100,    10_000   ],
+      [   1_000,     1_000   ],
+      [  10_000,       100   ],
+      [ 100_000,        10   ] ].each do
+      |     n_c,       n_s|
+      
+      do_bench_one(n_c, n_s) {|r| yield r}
+    end
+  end
+  
+  def self.do_bench_one(n_c, n_s)
+    w = make_world(n_c)
+    r = bench do
+      w.run(n_s)
+    end
+
+    yield "  - %10d comps X %10d steps: %8.2f" %
+      [n_c, n_s, r]
+  end
+end
+
+if __FILE__ == $0
+  require File.join(File.dirname(__FILE__), 'bench')
+  puts "half-strict:"
+  HalfStrict.do_bench_one(10_000, 100) {|l| puts l}
+end
+