redshift 1.3.15

data/bench/inertness.rb

@@ -0,0 +1,116 @@
+require 'redshift'
+require 'enumerator'
+
+include RedShift
+
+module Inertness
+  class Inert < Component
+    # An inert component is one that has no transitions out of its
+    # current state. However, flows are allowed. But for a sharper
+    # comparison, we don't define any.
+    #
+    #  flow do
+    #    diff " t' = 1 "
+    #  end
+  
+    # Adding just one trivial transition prevents the inert optimization,
+    # with dramatic effects (increase of 60% cpu time in first case).
+    #
+    # 1000 comps X      10000 steps X          0 non-inert:    +0.60
+    # 1000 comps X      10000 steps X          1 non-inert:    +0.59
+    #
+    #  transition Enter => Exit do
+    #    guard "0"
+    #  end
+    #
+    # Turning off the inert optimization in the world source, without adding
+    # a transition, is a bit less dramatic, but a more realistic indicator
+    # of the value of the optimization:
+    #
+    # 1000 comps X      10000 steps X          0 non-inert:    +0.39
+    # 1000 comps X      10000 steps X          1 non-inert:    +0.36
+  end
+
+  class NonInert < Component
+    n_states = 10
+      # increasing this doesn't make the difference (w/ and w/o the inert
+      # optimization) larger because the inerts go on strict sleep anyway.
+    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.1 "
+      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_inert, n_non_inert=0
+    w = World.new
+    n_inert.times {w.create(Inert)}
+    n_non_inert.times {w.create(NonInert)}
+    w
+  end
+
+  def self.do_bench
+    [0, 1].each do |n_non_inert|
+      [ [        0,  10_000],
+        [     1000,  10_000] ].each do
+        | n_inert,      n_s|
+
+        w = make_world(n_inert, n_non_inert)
+        w.run 1 # warm up
+        r = bench do
+          w.run(n_s)
+        end
+
+        yield "  - %10d comps X %10d steps X %10d non-inert: %8.2f" %
+          [n_inert, n_s, n_non_inert, r]
+      end
+    end
+  end
+end
+
+if __FILE__ == $0
+
+  require File.join(File.dirname(__FILE__), 'bench')
+  puts "inert:"
+  Inertness.do_bench {|l| puts l}
+
+exit
+
+  n_inert     = 10000
+  n_non_inert = 0
+  n_steps     = 1000
+
+
+  times = Process.times
+  t0 = Time.now
+  pt0 = times.utime #+ times.stime
+
+  w.run n_steps
+
+  times = Process.times
+  t1 = Time.now
+  pt1 = times.utime #+ times.stime
+  puts "process time: %8.2f" % (pt1-pt0)
+  puts "elapsed time: %8.2f" % (t1-t0)
+
+end
+
+__END__
+
+The best case so far is:
+
+without inert optimization
+process time:     6.58
+elapsed time:     6.59
+
+with inert optimization
+process time:     5.11
+elapsed time:     5.12

data/bench/queue.rb

@@ -0,0 +1,92 @@
+# Measures performance of redshift queues.
+
+require 'redshift'
+
+module Queue
+  class Clock < RedShift::Component
+    # the only continuous var in the whole system
+    strictly_continuous :time
+    flow {
+      diff " time' = 1 "
+    }
+  end
+  
+  class Sender < RedShift::Component
+    strict_link :clock => Clock
+    
+    constant :next_wakeup
+    strictly_constant :period
+    
+    # list of target queues that this comp will send to
+    def targets
+      @targets ||= []
+    end
+    
+    setup do
+      self.next_wakeup = period
+    end
+    
+    transition do
+      guard " clock.time >= next_wakeup "
+      reset :next_wakeup => " clock.time + period "
+      action do 
+        targets.each do |target|
+          target << :awake
+        end
+      end
+    end
+  end
+  
+  class Receiver < RedShift::Component
+    queue :q
+    transition do
+      wait :q
+      action do
+        q.pop
+      end
+    end
+  end
+  
+  def self.make_world n_sender=1, n_receiver=0
+    w = RedShift::World.new
+    clock = w.create(Clock)
+    n_sender.times do |i|
+      sender = w.create(Sender) do |s|
+        s.clock = clock
+        s.next_wakeup = ((i % 99)+1) / 10.0
+        s.period = 10
+        n_receiver.times do
+          w.create(Receiver) do |r|
+            s.targets << r.q
+          end
+        end
+      end
+    end
+    w
+  end
+
+  def self.do_bench
+    [1, 10, 100].each do |n_r|
+      [1, 10, 100].each do |n_s|
+        n_steps = 100_000 / (n_r * n_s)
+        do_bench_one(n_s, n_steps, n_r) {|r| yield r}
+      end
+    end
+  end
+  
+  def self.do_bench_one(n_s, n_steps, n_r)
+    w = make_world(n_s, n_r)
+    r = bench do
+      w.run(n_steps)
+    end
+
+    yield "  - %10d senders X %10d steps X %5d receivers: %8.2f" %
+      [n_s, n_steps, n_r, r]
+  end
+end
+
+if __FILE__ == $0
+  require File.join(File.dirname(__FILE__), 'bench')
+  puts "queue:"
+  Queue.do_bench_one(*ARGV.map{|s|s.to_i}) {|l| puts l}
+end

data/bench/run

@@ -0,0 +1,66 @@
+#!/usr/bin/env ruby
+
+require 'my-profile.rb'
+
+class Object
+  def rbprofile prof_flag = true
+    if block_given?
+      $profiler.instance_eval do
+        save = @do_profiling
+        @do_profiling = prof_flag
+        yield
+        @do_profiling = save
+      end
+    else
+      $profiler.instance_eval {@do_profiling = prof_flag}
+    end
+  end
+end
+
+bench_flag = ARGV.delete("b") || ARGV.delete("bench")
+profile_flag = ARGV.delete("p") || ARGV.delete("profile")
+rbprof_flag = ARGV.delete("rbprof")
+
+prog_name = ARGV.shift
+
+$REDSHIFT_CLIB_NAME = prog_name
+
+case
+when bench_flag
+  require prog_name; steps = $steps
+  require 'benchmark'
+  include Benchmark
+  bm(12) do |test|
+    for step in steps
+      test.report(step[0] + ":") do
+        step[1].call
+      end
+    end
+  end
+
+when profile_flag
+  require prog_name; steps = $steps
+  for step in steps
+#    require 'profile' if step[0] == "run"  # don't profile compilation
+    profile (step[0] == "run") do  # only profile run, not compile or create
+      step[1].call
+    end
+  end
+
+when rbprof_flag
+  require 'rbprof'; rbprofile false
+  require prog_name; steps = $steps
+  for step in steps
+    if step[0] == "run"  # don't profile compilation
+      rbprofile {step[1].call}
+    else
+      step[1].call
+    end
+  end
+
+else
+  require prog_name; steps = $steps
+  for step in steps
+    step[1].call
+  end
+end

data/bench/simple.rb

@@ -0,0 +1,74 @@
+require 'redshift'
+
+class Thing < RedShift::Component
+  flow {
+    diff "w' = 1"
+    alg  "ww = 2*w + (sin(w) + cos(w))*(sin(w) + cos(w))"
+    alg "www = ww-2"
+    diff "u' = www"
+  }
+  def inspect data = nil
+    d = "; #{data}" if data
+    vars = [
+      "w = #{w}"
+    ]
+    super "#{vars.join(", ")}#{d}"
+  end
+end
+
+class Base < RedShift::Component
+  flow {
+    diff "x' = 1"
+  }
+  def inspect data = nil
+    d = "; #{data}" if data
+    vars = [
+      "x = #{x}"
+    ]
+    super "#{vars.join(", ")}#{d}"
+  end
+end
+
+class Tester < Base
+  link :thing  => Thing
+  flow {
+    alg  "xx = 3*x"
+    diff "y' = xx"
+    diff "z' = y + 4*(thing.w+thing.u)"
+  }
+
+  def inspect data = nil
+    d = "; #{data}" if data
+    vars = [
+      "xx = #{xx}",
+      "y = #{y}",
+      "z = #{z}"
+    ]
+    super "#{vars.join(", ")}#{d}"
+  end
+  
+  setup do
+    self.thing = create Thing
+  end
+end
+
+#----------------------------------#
+
+n_obj = 100
+n_iter = 100_000
+
+# 10, 100_000 ==> 8.87 seconds
+
+world = nil
+$steps = [
+  ["commit", proc { world = RedShift::World.new {|w| w.time_step = 0.05} }],
+  ["create", proc { n_obj.times do world.create Tester end }],
+  ["run",    proc { world.run n_iter }]
+]
+
+END {
+#  puts "time_step = #{world.time_step}"
+#  puts "clock = #{world.clock}"
+#  t = world.find { |c| c.is_a? Tester }
+#  p t
+}

data/bench/strictness.rb

@@ -0,0 +1,86 @@
+require 'my-profile'
+
+$strict = ARGV.delete("-s")
+
+# This makes a 5x difference!
+if $strict
+  $REDSHIFT_CLIB_NAME = "strictness-on"
+else
+  $REDSHIFT_CLIB_NAME = "strictness-off"
+end
+
+require 'redshift'
+include RedShift
+
+class SimpleComponent < Component
+
+  continuous :x
+  if $strict
+    strictly_continuous :y
+    strict_link :other => SimpleComponent
+  else
+    continuous :y
+    link :other => SimpleComponent
+  end
+
+  state :A, :B; default { start A; self.other = self }
+  
+  flow A do
+    diff " y' = 1 + x " # y still strict even though x is not
+  end
+  
+  5.times do
+    transition A => B do
+      guard " pow(y, 2) - sin(y) + cos(y) + other.y < 0 "
+    end
+  end
+
+end
+
+class ComplexComponent < Component
+  
+  attr_accessor :start_value
+  
+  state :A, :B, :C, :D, :E1, :F; default { start A }
+  
+  flow A do
+    diff "t' = 1"
+  end
+  
+  transition A => B do
+    guard "t > 1"
+    action do
+      if @start_value
+        self.t = @start_value
+        @start_value = nil
+      else
+        self.t = 0
+      end
+    end
+  end
+  
+  transition B => C, C => D, D => E1, E1 => F, F => A
+  
+end
+
+n = 1000
+hz = 100
+ts = 1.0/hz
+w = World.new { |w| w.time_step = ts }
+n.times do w.create SimpleComponent end
+hz.times do |i|
+  cc = w.create ComplexComponent
+  cc.start_value = i*ts
+end
+
+times = Process.times
+t0 = Time.now
+pt0 = times.utime #+ times.stime
+profile false do
+  w.run 1000
+end
+times = Process.times
+t1 = Time.now
+pt1 = times.utime #+ times.stime
+puts "process time: %8.2f" % (pt1-pt0)
+puts "elapsed time: %8.2f" % (t1-t0)

data/examples/ball-tkar.rb

@@ -0,0 +1,72 @@
+# Example showing how to use tkar to animate a redshift simulation.
+#
+# Tkar can be found at http://path.berkeley.edu/~vjoel/vis/tkar
+
+require 'redshift'
+include RedShift
+
+class Ball < Component
+  continuous :x, :y, :v
+  
+  flow do
+    diff "y' = v"
+    diff "v' = -9.8"
+  end
+  
+  transition do
+    guard "y - 5 < 0 && v < 0"
+    reset :v => "-v"
+  end
+  
+  attr_accessor :id # so we can keep track of which is which in animation
+end
+
+world = World.new
+#world.time_step = 0.01
+
+ball_count = 10
+balls = Array.new(ball_count) do |id|
+  world.create(Ball) do |ball|
+    ball.x = id * 10
+    ball.y = rand(450) + 100
+    ball.v = 0
+    ball.id = id
+  end
+end
+
+begin
+  ## need --quiet option?
+  IO.popen("tkar --flip -v", "w") do |tkar|
+    # --flip means positive y is up
+    tkar.puts %{
+      title Bouncing ball
+      background gray95
+      height 600
+      width 600
+      bounds -300 0 300 600
+      shape ball oval-5,-5,5,5,fc:darkgreen,oc:red
+      shape ground line*0,0,*1,0,fc:purple,wi:4
+      add ground 10000 - 10 0 0 0 -300 300
+      view_at 0 540
+    }
+    balls.each do |ball|
+      tkar.puts %{
+        add ball #{ball.id} - 100 #{ball.x} #{ball.y} 0
+      }
+    end
+    tkar.flush
+    world.evolve 1000 do
+      balls.each do |ball|
+        tkar.puts "move #{ball.id} #{ball.x} #{ball.y}"
+      end
+      tkar.puts "update"
+      tkar.flush
+      #sleep 0.01
+      ## need timer to make this realistic
+    end
+    puts "Press <enter> when done"
+    gets
+  end
+rescue Errno::EPIPE, Interrupt
+  puts "Exited."
+end