roby 0.8.0 → 3.0.0

data/benchmark/attic/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
+

data/benchmark/plan_basic_operations.rb

@@ -0,0 +1,28 @@
+require 'roby'
+require 'benchmark'
+
+require 'ruby-prof'
+
+COUNT = 1000
+Benchmark.bm(30) do |x|
+    x.report("allocates #{COUNT} tasks") do
+        COUNT.times { Roby::Task.new }
+    end
+
+    plan = Roby::Plan.new
+    tasks = (1..COUNT).map { Roby::Task.new }
+    x.report("adds #{COUNT} tasks") do
+        tasks.each { |t| plan.add(t) }
+    end
+
+    plan = Roby::Plan.new
+    tasks = (1..COUNT).map { Roby::Task.new }
+    x.report("add 1 time #{COUNT} tasks") do
+        plan.add(tasks)
+    end
+
+    x.report("remove 1 tasks #{tasks.size} times") do
+        tasks.each { |t| plan.remove_task(t) }
+    end
+end
+

data/benchmark/relations/graph.rb

@@ -0,0 +1,63 @@
+require 'roby'
+require 'benchmark'
+
+require 'ruby-prof'
+
+class Graph < Roby::Relations::Graph
+end
+
+class Vertex
+    include Roby::Relations::DirectedRelationSupport
+
+    attr_reader :relation_graphs
+    def initialize(graph)
+        @relation_graphs = Hash[graph => graph, graph.class => graph]
+    end
+end
+
+COUNT = 10_000
+Benchmark.bm(80) do |x|
+    tasks = Array.new
+
+    graph = Graph.new
+    vertices = (1..COUNT).map { Vertex.new(graph) }
+    x.report("add #{COUNT} vertices") do
+        vertices.each { |o| graph.add_vertex(o) }
+    end
+    x.report("remove #{COUNT} vertices") do
+        vertices.each { |o| graph.remove_vertex(o) }
+    end
+
+    graph = Graph.new
+    vertices = (1..2*COUNT).map { Vertex.new(graph) }
+    vertices.each { |o| graph.add_vertex(o) }
+    x.report("#{COUNT} separate links between already inserted vertices") do
+        vertices.each_slice(2) { |parent, child| graph.add_relation(parent, child, nil) }
+    end
+    x.report("unlink #{COUNT} separate links") do
+        vertices.each_slice(2) { |parent, child| graph.remove_relation(parent, child) }
+    end
+
+    graph = Graph.new
+    vertices = (1..2*COUNT).map { Vertex.new(graph) }
+    x.report("#{COUNT} separate links, inserted vertices") do
+        vertices.each_slice(2) { |parent, child| graph.add_relation(parent, child, nil) }
+    end
+
+    graph = Graph.new
+    graph.add_vertex(shared_v = Vertex.new(graph))
+    vertices = (1..COUNT).map { Vertex.new(graph) }
+    vertices.each { |o| graph.add_vertex(o) }
+    x.report("#{COUNT} links with a shared vertex between already inserted vertices") do
+        vertices.each { |o| graph.add_relation(shared_v, o, nil) }
+    end
+
+    graph = Graph.new
+    shared_v = Vertex.new(graph)
+    vertices = (1..COUNT).map { Vertex.new(graph) }
+    x.report("#{COUNT} links with a shared vertex, inserting vertices at the same time") do
+        vertices.each { |o| graph.add_relation(shared_v, o, nil) }
+    end
+end
+
+

data/benchmark/ruby/identity.rb

@@ -0,0 +1,18 @@
+require 'benchmark'
+
+obj = Object.new
+lambda_identity = lambda { |v| v }
+proc_identity = proc { |v| v }
+hash_identity = Hash.new { |h,k| k }
+klass = Class.new do
+    def self.identity(obj); obj end
+end
+method_identity = klass.method(:identity)
+
+Benchmark.bm(7) do |bm|
+    bm.report('lambda') { 10_000_000.times { lambda_identity.call(obj) } }
+    bm.report('hash') { 10_000_000.times { hash_identity[obj] } }
+    bm.report('proc') { 10_000_000.times { proc_identity[obj] } }
+    bm.report('method') { 10_000_000.times { method_identity[obj] } }
+end
+

data/benchmark/ruby/set_intersect_vs_hash_merge.rb

@@ -0,0 +1,39 @@
+require 'benchmark'
+require 'set'
+
+class Set
+    def intersect_with_merge(other)
+        result = Set.new
+        @hash.merge(other.instance_variable_get(:@hash)) do |k, _|
+            result << k
+        end
+        result
+    end
+end
+
+Benchmark.bm(40) do |x|
+    [1, 10, 100, 1000].each do |count|
+
+        sets = Array.new
+        10000.times do
+            elements = (0..count * 2).to_a
+            left = Set.new
+            right = Set.new
+            count.times do
+                left << (elements[rand(count * 2)])
+                right << (elements[rand(count * 2)])
+            end
+            sets << [left, right]
+        end
+        x.report("#{count}: Set#intersect") do
+            sets.each do |left, right|
+                left & right
+            end
+        end
+        x.report("#{count}: Set#intersect_with_merge") do
+            sets.each do |left, right|
+                left.intersect_with_merge(right)
+            end
+        end
+    end
+end

data/benchmark/ruby/yield_vs_block.rb

@@ -0,0 +1,35 @@
+require 'benchmark'
+
+def call_yield(enum)
+    enum.each { |v| yield(v) }
+end
+
+def call_block(enum, &b)
+    enum.each(&b)
+end
+
+enum       = (1..10_000_000)
+cost_of_call = 10_000_000
+call_count = 1_000
+call_enum  = (1..100)
+Benchmark.bm(40) do |x|
+    x.report("yield - enumerate %.0e elements" % [enum.size]) do
+        call_yield(enum) { |v| }
+    end
+    x.report("block - enumerate %.0e elements" % [enum.size]) do
+        call_block(enum) { |v| }
+    end
+    x.report("yield - %.0e calls" % [cost_of_call]) do
+        cost_of_call.times { call_yield((1..1)) { |v| } }
+    end
+    x.report("block - %.0e calls" % [cost_of_call]) do
+        cost_of_call.times { call_block((1..1)) { |v| } }
+    end
+    x.report("yield - %.0e calls and %.0e elements" % [call_count, call_enum.size]) do
+        call_count.times { call_yield(call_enum) { |v| } }
+    end
+    x.report("block - %.0e calls and %.0e elements" % [call_count, call_enum.size]) do
+        call_count.times { call_block(call_enum) { |v| } }
+    end
+end
+

data/benchmark/run

@@ -0,0 +1,5 @@
+#! /usr/bin/env ruby
+require_relative 'relations/graph'
+require_relative 'plan_basic_operations'
+require_relative 'transactions'
+require_relative 'synthetic_plan_modifications_with_transactions'

data/benchmark/synthetic_plan_modifications_with_transactions.rb

@@ -0,0 +1,79 @@
+require 'roby'
+require 'benchmark'
+
+def randomly_modify_plan(plan, num_tasks, num_relation_changes, num_mission_changes, commit: true)
+    plan.in_transaction do |trsc|
+        num_tasks = num_tasks / 10 * 10
+        if plan.num_tasks < num_tasks
+            (num_tasks - plan.num_tasks).times do
+                trsc.add(Roby::Task.new)
+            end
+        end
+        tasks = (plan.tasks.to_a + trsc.tasks.to_a)
+
+        num_relation_changes.times do
+            from_group, to_group = 0, 0
+            while from_group == to_group
+                from_group = rand(tasks.size / 10)
+                to_group   = rand(tasks.size / 10)
+            end
+            if from_group > to_group
+                from_group, to_group = to_group, from_group
+            end
+            from_i = from_group * 10 + rand(10)
+            to_i   = to_group * 10 + rand(10)
+
+            from = tasks[from_i]
+            to   = tasks[to_i]
+
+            if from.plan == to.plan && from.depends_on?(to)
+                trsc[from].remove_child trsc[to]
+            else
+                trsc[from].depends_on trsc[to]
+            end
+        end
+
+        # Unmark all missions
+        all_missions = plan.mission_tasks.to_a + trsc.mission_tasks.to_a
+        all_missions.each do |t|
+            trsc.unmark_mission_task(trsc[t])
+        end
+
+        # And randomly mark mission_count tasks
+        num_mission_changes.times do
+            task = tasks[rand(tasks.size)]
+            trsc.add_mission_task(trsc[task])
+        end
+
+        if commit
+            trsc.commit_transaction
+        end
+    end
+end
+
+COUNT = 10
+Benchmark.bm(30) do |x|
+    num_tasks            = 100
+    num_relation_changes = 500
+    num_mission_changes  = 10
+
+    x.report "modifies an executable plan using a transaction (#{COUNT} times)" do
+        plan = Roby::ExecutablePlan.new
+        Roby::ExecutionEngine.new(plan)
+
+        COUNT.times do |i|
+            randomly_modify_plan(plan, num_tasks, num_relation_changes, num_mission_changes, commit: false)
+        end
+    end
+
+    x.report "modifies and commits an executable plan using a transaction (#{COUNT} times)" do
+        plan = Roby::ExecutablePlan.new
+        Roby::ExecutionEngine.new(plan)
+
+        COUNT.times do |i|
+            randomly_modify_plan(plan, num_tasks, num_relation_changes, num_mission_changes)
+        end
+    end
+end
+
+

data/benchmark/transactions.rb

@@ -1,62 +1,110 @@
-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'
+require 'benchmark'
+
+require 'ruby-prof'
 
-include Roby
+def random_plan(plan, num_tasks, num_task_relations, num_event_relations)
+    num_tasks = num_tasks / 10 * 10
+    num_tasks.times do
+        plan.add(Roby::Task.new)
+    end
 
-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}" }
+    tasks = plan.tasks.to_a
+    num_task_relations.times do
+        from_group, to_group = 0, 0
+        while from_group == to_group
+            from_group = rand(tasks.size / 10)
+            to_group   = rand(tasks.size / 10)
+        end
+        if from_group > to_group
+            from_group, to_group = to_group, from_group
+        end
+        from_i = from_group * 10 + rand(10)
+        to_i   = to_group * 10 + rand(10)
 
-    puts "  #{count.join("\n  ")}"
+        from = tasks[from_i]
+        to   = tasks[to_i]
+
+        from.depends_on to
+    end
+
+    forward_graph = plan.event_relation_graph_for(Roby::EventStructure::Forwarding)
+    events = plan.free_events.to_a + plan.task_events.to_a
+    while forward_graph.num_edges < num_event_relations
+        from_group, to_group = 0, 0
+        while from_group == to_group
+            from_group = rand(events.size / 10)
+            to_group   = rand(events.size / 10)
+        end
+        if from_group > to_group
+            from_group, to_group = to_group, from_group
+        end
+        from_i = from_group * 10 + rand(10)
+        to_i   = to_group * 10 + rand(10)
+
+        from = events[from_i]
+        to   = events[to_i]
+        if from.task != to.task
+            from.forward_to to
+        end
+    end
 end
 
+COUNT = 1000
+Benchmark.bm(70) do |x|
+    plan = Roby::Plan.new
+    (1..10).map do
+        plan.add(Roby::Task.new)
+    end
+    tasks = plan.tasks.to_a
+    plan.add(task = Roby::Task.new)
+
+    x.report("creating #{COUNT} transactions") do
+        COUNT.times do
+            trsc = Roby::Transaction.new(plan)
+        end
+    end
+    x.report("import non-connected task from plan (#{COUNT} times)") do
+        COUNT.times do
+            trsc = Roby::Transaction.new(plan)
+            trsc[task]
+        end
+    end
+
+    tasks[0].depends_on task
+    task.depends_on tasks[1]
+    task.start_event.forward_to tasks[2].stop_event
+    tasks[3].stop_event.signals task.start_event
+
+    x.report("import one connected task from plan (#{COUNT} times)") do
+        COUNT.times do
+            trsc = Roby::Transaction.new(plan)
+            trsc[task]
+        end
+    end
+
+    plan = Roby::ExecutablePlan.new
+    Roby::ExecutionEngine.new(plan)
+    random_plan(plan, 100, 120, 2000)
+
+    x.report("import random plan iteratively (10 times and 100 tasks/plan)") do
+        10.times do
+            trsc = Roby::Transaction.new(plan)
+            plan.tasks.each do |t|
+                trsc[t]
+            end
+        end
+    end
 
+    plan = Roby::ExecutablePlan.new
+    Roby::ExecutionEngine.new(plan)
+    random_plan(plan, 100, 120, 2000)
 
-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
+    x.report("import random plan using find_tasks (10 times and 100 tasks/plan)") do
+        10.times do
+            trsc = Roby::Transaction.new(plan)
+            trsc.find_tasks.to_a
+        end
     end
 end
-build_and_commit