roby 0.7.3 → 0.8.0

data/app/config/app.yml

@@ -1,17 +1,6 @@
 # Control configuration
-control:
-  # Abort if a task/event exception is not caught 
-  # abort_on_exception: false
-  # Abort if an application exception occurs 
-  # abort_on_application_exception: false
-  
-  # The executive. Set to 'none' to disable.
-  # The executive object determines, in the current plan, what are
-  # the tasks which must be started. The 'simple' executive starts
-  # all tasks that have no predecessors.
-  executive: simple
-
-  # The length of a cycle (in seconds)
+engine:
+  # The length of a cycle (in seconds). It defaults to 100ms.
   # cycle: 0.1
 
 # Logging configuration
@@ -19,10 +8,25 @@ log:
   # Where log files go
   # dir: log/
   
-  # Log system events (default: false)
+  # Log system events. It can be either true, false or stats. If true, all
+  # plan-level events are logged, allowing to use the roby-log GUI to replay
+  # the plans. If false, nothing is logged. If set to stats, only execution
+  # statistics are logged. This mode is useful to monitor execution latencies
+  # without having the big impact of full logging.
+  #
+  # See the roby-log tool to read the generated files, Roby::Log::Logfile to read the
+  # files from a Ruby script and Roby::Log::Timings for reading and using per-cycle
+  # statistics.
+  #
+  # The default is stats
+  #
   # events: true
   
-  # Disables the log server (default: enabled)
+  # Set to false to disables the log server and true to enable it (it is enabled by
+  # default). The log server allows to display the controller state remotely by using the
+  # <tt>roby-log</tt> tool. Note that it is completely separated from the Roby remote
+  # shell, which is always enabled.
+  #
   # server: false
   #
   # ... or configure it
@@ -32,17 +36,32 @@ log:
   #     # The discovery period
   #     period: 10
 
-  # Logging levels. It is a hash of component_name: level (where level is one
-  # of DEBUG, INFO, WARN and FATAL). The output can be redirected in a file
-  # using level:filename, in which case 'filename' is relative to the log
-  # directory. Any occurence of 'ROBOT' in filename is replaced by the robot
-  # name
+  # Logging levels.
+  #
+  # Logging in Roby is controlled per-module in a hierarchical way. It means that to get
+  # debugging output for the whole framework, set
+  #
+  # levels:
+  #     roby: DEBUG
+  #
+  # now, if you want to have it do debug for everything but the classes in
+  # Roby::Distributed, do
+  #
+  # levels:
+  #     roby: DEBUG
+  #     roby/distributed: INFO
+  #
+  # The available logging levels are DEBUG, INFO, WARN and FATAL. The output can be
+  # redirected in a file using level:filename, in which case 'filename' is relative to the
+  # log directory. Any occurence of 'ROBOT' in filename is replaced by the robot name. For
+  # instance, in a 'dala' robot, the following setup would redirect the debugging outut of
+  # Roby::Distributed classes into data-distributed.log:
   #
   # levels:
-  #   roby: INFO
-  #   roby/planning: DEBUG
   #   roby/distributed: DEBUG:ROBOT-distributed.log
-  #   genom: INFO
+  #
+  # Log files are saved in the log directory (controlled by the 'dir' option above, it is
+  # 'log' by default).
 
 # dRoby neighbour discovery
 discovery:
@@ -62,26 +81,6 @@ droby:
   # 'host:port', or just ':port'
   # host: ":48902"
 
-# Genom configuration
-genom:
-  # The memory size allocated for H2
-  # mem_size: 4000000
-  # If true, do not remove H2 devices when the application quit
-  # keep_h2: false
-  
-# Pocosim configuration
-pocosim:
-  # The host of the GDHE display
-  # display: localhost
-
-  # An initialization script to display the scene on GDHE. The file is searched
-  # in the data/ director
-  # gdhe: lousa.gdhe
-  
-  # The Gazebo world file for pocosim/gazebo simulations. The file is searched
-  # in the data/ directory 
-  # gazebo: lousa.world
-
 # Per-robot configuration. In these, you can override global options, or set
 # new options.
 # dala:

data/app/config/init.rb

@@ -5,3 +5,29 @@
 # Roby.app.using 'fault_injection'
 # Roby.app.using 'subsystems'
 
+##############################
+# Sets some configuration options
+#
+# If true, the engine aborts if an uncaught task or event exception is
+# received. Defaults to false, as Roby has meaningful ways to handle those
+#  Roby.app.abort_on_exception = false
+#
+# If true, the engine aborts if an exception is raised outside of the reach of
+# the plan-based error management. Defaults to true, as there is no safe ways
+# to handle those.
+#  Roby.app.abort_on_application_exception = true
+
+##############################
+# Set the decision control object to be used during execution (can also be
+# done per-robot)
+#
+# Roby.control = Roby::DecisionControl.new
+
+
+##############################
+# Set the scheduler object to be used during execution (can also be done
+# per-robot by setting it in config/#{ROBOT}.rb)
+
+require 'roby/schedulers/basic'
+Roby.scheduler = Roby::Schedulers::Basic.new
+

data/benchmark/alloc_misc.rb

@@ -0,0 +1,123 @@
+require 'utilrb/objectstats'
+require 'utilrb/value_set'
+require 'enumerator'
+require 'set'
+
+GC.disable
+
+puts "==== Iteration"
+[(1..10_000), (1..10_000).to_a, (1..10_000).to_value_set, (1..10_000).enum_for, (1..10_000).to_set].each do |set|
+    before = ObjectSpace.live_objects
+    for obj in set
+	10
+    end
+    after  = ObjectSpace.live_objects
+    puts "#{set.class} for: #{after - before}"
+
+    before = ObjectSpace.live_objects
+    set.each { |obj| 10 }
+    after  = ObjectSpace.live_objects
+    puts "#{set.class} each: #{after - before}"
+end
+
+puts "\n===== Method calls"
+def bm_args_yield(a, b)
+    yield(a, b) if block_given?
+end
+def bm_args_yield_through_block(a, b, &block)
+    block.call(a, b) if block
+end
+
+def bm_method_call
+end
+
+def bm_yield
+    yield
+end
+def bm_block_yield(&block)
+    yield
+end
+
+def bm_block(do_call, &block)
+    block.call if do_call
+end
+
+class Test
+    def bla
+    end
+end
+class Foo < Test
+    def bla
+	super
+    end
+end
+
+
+before = ObjectSpace.live_objects
+bm_method_call
+after  = ObjectSpace.live_objects
+puts "Method call: #{after - before}"
+
+test = Foo.new
+before = ObjectSpace.live_objects
+test.bla
+after = ObjectSpace.live_objects
+puts "Method call with super: #{after - before}"
+
+before = ObjectSpace.live_objects
+bm_method_call { 10 }
+after  = ObjectSpace.live_objects
+puts "Method call with block m(): #{after - before}"
+
+before = ObjectSpace.live_objects
+bm_block(false) { 10 }
+after  = ObjectSpace.live_objects
+puts "Method call with block m(&block): #{after - before}"
+
+before = ObjectSpace.live_objects
+bm_yield { 10 }
+after  = ObjectSpace.live_objects
+puts "Yield: #{after - before}"
+
+before = ObjectSpace.live_objects
+bm_block(true) { 10 }
+after  = ObjectSpace.live_objects
+puts "Block & #call: #{after - before}"
+
+before = ObjectSpace.live_objects
+bm_block_yield { 10 }
+after  = ObjectSpace.live_objects
+puts "Block and yield: #{after - before}"
+
+p = Proc.new { 10 }
+before = ObjectSpace.live_objects
+p.call
+after  = ObjectSpace.live_objects
+puts "Proc#call: #{after - before}"
+
+puts "\n=== Exceptions"
+def bm_exception
+rescue
+ensure
+end
+before = ObjectSpace.live_objects
+begin
+rescue Exception
+ensure
+end
+after  = ObjectSpace.live_objects
+puts "begin-rescue-ensure: #{after - before}"
+
+before = ObjectSpace.live_objects
+bm_exception
+after  = ObjectSpace.live_objects
+puts "begin-rescue-ensure method: #{after - before}"
+
+puts "\n=== Misc"
+before = ObjectSpace.live_objects
+defined? yield
+after  = ObjectSpace.live_objects
+puts "defined?: #{after - before}"
+
+
+

data/benchmark/discovery_latency.rb

@@ -0,0 +1,67 @@
+TOP_SRC_DIR = File.expand_path( File.join(File.dirname(__FILE__), '..') )
+$LOAD_PATH.unshift TOP_SRC_DIR
+$LOAD_PATH.unshift File.join(TOP_SRC_DIR, 'test')
+
+require 'roby/distributed/connection_space'
+
+TEST_SIZE=20
+BASE_PERIOD=0.5
+
+include Roby
+include Roby::Distributed
+BROADCAST = (1..10).map { |i| "127.0.0.#{i}" }
+
+def test(discovery_period)
+    start_r, start_w= IO.pipe
+    quit_r, quit_w = IO.pipe
+    remote_pid = fork do
+	start_r.close
+	quit_w.close
+
+	DRb.start_service
+	Distributed.state = ConnectionSpace.new :period => discovery_period, :ring_discovery => true, :ring_broadcast => BROADCAST
+	Distributed.publish :bind => '127.0.0.2'
+
+	start_w.write('OK')
+	quit_r.read(2)
+	Distributed.unpublish
+    end
+    start_w.close
+    quit_r.close
+    start_r.read(2)
+
+    DRb.start_service
+    Distributed.state = ConnectionSpace.new :period => discovery_period, :ring_discovery => true, :ring_broadcast => BROADCAST
+    Distributed.publish :bind => '127.0.0.1'
+
+    Distributed.state.start_neighbour_discovery
+    Distributed.state.wait_discovery
+    raise unless Distributed.neighbours.find { |n| n.name == "#{Socket.gethostname}-#{remote_pid}" }
+
+ensure
+    Distributed.unpublish
+    start_r.close
+    quit_w.write('OK')
+    Process.waitpid(remote_pid)
+end
+
+period = BASE_PERIOD
+error_count = 0
+while (error_count.to_f / TEST_SIZE) < 0.1
+    error_count = 0
+    STDERR.print "#{period}"
+    (0..TEST_SIZE).each do |i|
+	begin
+	    test(period)
+	rescue Exception => e
+	    if e.class != RuntimeError
+		STDERR.puts e.message
+	    end
+	    error_count += 1
+	end
+	STDERR.print "\r#{period} (#{i}|#{error_count}|#{TEST_SIZE})"
+    end
+    STDERR.puts
+    period /= 2
+end
+

data/benchmark/garbage_collection.rb

@@ -0,0 +1,48 @@
+#! /usr/bin/env ruby
+require 'roby'
+require 'benchmark'
+include Roby
+
+TASK_COUNT  = 100
+EVENT_COUNT = 50
+RELATION_COUNT = 200
+
+tasks  = (1..TASK_COUNT).map { Task.new }
+events = (1..EVENT_COUNT).map { EventGenerator.new }
+
+plan = Plan.new
+tasks.each { |t| plan.permanent(t) }
+plan.discover(events)
+
+objects = tasks + events
+RELATION_COUNT.times do
+    parent = objects.random_element
+    child  = objects.random_element
+    next if parent == child
+
+    if parent.kind_of?(EventGenerator)
+	if !child.kind_of?(EventGenerator)
+	    child = child.bound_events.random_element.last
+	end
+    elsif child.kind_of?(EventGenerator)
+	parent = parent.bound_events.random_element.last
+    end
+
+    relation = if parent.kind_of?(EventGenerator)
+		   EventStructure.relations.random_element
+	       else
+		   TaskStructure.relations.random_element
+	       end
+
+    begin
+	parent.add_child_object(child, relation, :success => [], :failure => [])
+    rescue CycleFoundError
+    end
+end
+
+Benchmark.bm(15) do |bm|
+    bm.report("unneeded_events") { plan.unneeded_events }
+    bm.report("unneeded_tasks")  { plan.unneeded_tasks }
+    bm.report("garbage_collect") { plan.garbage_collect }
+end
+

data/benchmark/genom.rb

@@ -0,0 +1,31 @@
+TOP_SRC_DIR = File.expand_path( File.join(File.dirname(__FILE__), '..') )
+$LOAD_PATH.unshift TOP_SRC_DIR
+$LOAD_PATH.unshift File.join(TOP_SRC_DIR, 'test')
+require 'test_config'
+require 'genom/runner'
+require 'roby/adapters/genom'
+
+include Roby
+
+GC.disable
+::Genom::Runner.h2 do |env|
+    ::Genom.connect do
+        Roby::Genom::GenomModule('mockup')
+        env.start_modules('mockup')
+
+        task = Roby::Genom::Mockup.start
+        task.start!
+
+        while !task.running?
+            $stderr.puts "waiting for task to start"
+            Roby.process_events
+        end
+
+        task.activity.abort.wait
+        while !task.finished?
+            $stderr.puts "waiting for task to end"
+            Roby.process_events
+        end
+    end
+end
+

data/benchmark/transactions.rb

@@ -0,0 +1,62 @@
+TOP_SRC_DIR = File.expand_path( File.join(File.dirname(__FILE__), '..') )
+$LOAD_PATH.unshift TOP_SRC_DIR
+$LOAD_PATH.unshift File.join(TOP_SRC_DIR, 'test')
+
+require 'roby'
+require 'roby/transactions'
+require 'utilrb/objectstats'
+
+include Roby
+
+TASK_COUNT = 10
+RELATION_COUNT = 10
+def display_object_count
+    count = ObjectStats.count_by_class.
+	find_all { |k, o| k.name =~ /Roby/ }.
+	sort_by { |k, o| k.name }.
+	map { |k, o| "#{k} #{o}" }
+
+    puts "  #{count.join("\n  ")}"
+end
+
+
+
+def build_and_commit
+    plan = Plan.new
+
+    BenchmarkAllocation.bmbm(7) do |x|
+	trsc = Transaction.new(plan)
+	plan_tasks, trsc_tasks = nil
+	x.report("alloc") do
+	    trsc_tasks = (1..TASK_COUNT).map { trsc.discover(t = Task.new); t } 
+	    plan_tasks = (1..TASK_COUNT).map { plan.discover(t = Task.new); trsc[t] }
+	end
+
+	# Add random relations
+	arrays = [plan_tasks, trsc_tasks]
+	relation_count = [0, 0]
+
+	from_origin, to_origin = (1..2).map { rand(2) }
+	x.report("relations") do
+	    RELATION_COUNT.times do
+		from = arrays[from_origin][rand(TASK_COUNT)]
+		to   = arrays[to_origin][rand(TASK_COUNT)]
+		relation_count[from_origin] += 1
+		relation_count[to_origin] += 1
+		begin
+		    from.realized_by to
+		rescue CycleFoundError
+		end
+	    end
+	end
+
+	x.report("commit") do
+	    trsc.commit_transaction
+	end
+	x.report("clear") do
+	    plan.clear
+	end
+    end
+end
+build_and_commit
+