roby 0.7.3 → 0.8.0

data/lib/roby/log/relations.rb

@@ -419,6 +419,18 @@ module Roby
 
 	    include TaskDisplaySupport
 
+            def self.all_task_relations
+                if @all_task_relations
+                    @all_task_relations
+                else
+                    result = []
+                    ObjectSpace.each_object(Roby::RelationSpace) do |space|
+                        result.concat(space.relations) if space.applied.find { |t| t <= Roby::Task }
+                    end
+                    @all_task_relations = result
+                end
+            end
+
 	    attr_reader :ui, :scene
 
 	    # A [DRbObject, DRbObject] => GraphicsItem mapping of arrows
@@ -510,25 +522,31 @@ module Roby
 		obj
 	    end
 
+            # Initializes the display with the data already decoded from the
+            # given data stream, and binds this display to the stream.
 	    def stream=(data_stream)
 		super
 
 		# Initialize the display ...
 		decoder.plans.each do |plan|
-		    discovered_tasks(Time.now, plan, plan.known_tasks)
-		    discovered_events(Time.now, plan, plan.free_events)
+		    added_tasks(Time.now, plan, plan.known_tasks)
+		    added_events(Time.now, plan, plan.free_events)
 		end
 		display
 	    end
 
 	    def [](item); graphics[item] end
+
+            # Returns a canvas object that represents this relation
 	    def task_relation(from, to, rel, info)
 		arrow(from, to, rel, info, TASK_LAYER)
 	    end
+            # Returns a canvas object that represents this relation
 	    def event_relation(form, to, rel, info)
 		arrow(from, to, rel, info, EVENT_LAYER)
 	    end
 
+            # Creates or reuses an arrow object to represent the given relation
 	    def arrow(from, to, rel, info, base_layer)
 		id = [from, to, rel]
 		unless item = arrows[id]
@@ -589,9 +607,14 @@ module Roby
 		COLORS[current_color]
 	    end
 
+            # True if this relation should be displayed
 	    def relation_enabled?(relation); @enabled_relations.include?(relation) end
+            # True if this relation should be used for layout
+            #
+            # See also #relation_enabled?, #layout_relation, #ignore_relation
 	    def layout_relation?(relation); relation_enabled?(relation) || @layout_relations.include?(relation) end
 
+            # Display this relation
 	    def enable_relation(relation)
 		return if relation_enabled?(relation)
 		@enabled_relations << relation
@@ -602,11 +625,17 @@ module Roby
 		end
 	    end
 
+            # The set of relations that should be displayed
 	    attr_reader :enabled_relations
+
+            # Use this relation for layout but not for display
+            #
+            # See also #ignore_relation
 	    def layout_relation(relation)
 		disable_relation(relation)
 		@layout_relations << relation
 	    end
+            # Don't use this relation at all
 	    def ignore_relation(relation)
 		disable_relation(relation)
 		@layout_relations.delete(relation)
@@ -756,19 +785,22 @@ module Roby
 	    end
 
 	    def clear_integrated
-		postponed_events.clear
-		execution_events.clear
-		@execution_events = execution_events.find_all { |fired, ev| !fired }
+                unless keep_signals
+                    last_propagated_events, @propagated_events = propagated_events, Array.new
+                    last_execution_events, @execution_events = 
+                        execution_events.partition { |fired, ev| fired }
+                end
+                !(last_propagated_events.empty? && last_execution_events.empty?)
 	    end
 
+            # Update the display with new data that has come from the data
+            # stream. 
+            #
+            # It would be too complex at this stage to know if the plan has been
+            # updated, so the method always returns true
 	    def update
 		return unless decoder
 
-		if keep_signals
-		    @execution_events = @last_execution_events.concat(execution_events)
-		    @propagated_events.concat @last_propagated_events
-		end
-
 		update_prefixes_removal
 		clear_flashing_objects
 
@@ -912,11 +944,7 @@ module Roby
 		    end
 		end
 
-		@last_propagated_events, @propagated_events = propagated_events, Array.new
-		@last_execution_events, @execution_events = 
-		    execution_events.partition { |fired, ev| fired }
-
-		postponed_events.clear
+                true
 	    end
 
 	    def remove_graphics(item, scene = nil)
@@ -995,7 +1023,7 @@ module Roby
 	    def removed_event_child(time, parent, rel, child)
 		remove_graphics(arrows.delete([local_event(parent), local_event(child), rel]))
 	    end
-	    def discovered_tasks(time, plan, tasks)
+	    def added_tasks(time, plan, tasks)
 		tasks.each do |obj| 
 		    obj.flags[:pending] = true if obj.respond_to?(:flags)
 		    task = local_task(obj)

data/lib/roby/log/server.rb

@@ -47,9 +47,6 @@ module Roby
 		discovered_displays = Array.new
 		@available_servers  = Array.new
 
-		# Add disable_discovery in the list of finalizers
-		Control.finalizers << method(:disable_discovery)
-
 		@discovery_thread = Thread.new do
 		    begin
 			loop do
@@ -75,7 +72,7 @@ module Roby
 
 	    # Stops the discovery thread if it is running
 	    def self.disable_discovery
-		Control.finalizers.delete(method(:disable_discovery))
+		Roby.engine.finalizers.delete(method(:disable_discovery))
 		if @discovery_thread
 		    @discovery_thread.raise Interrupt, "quitting"
 		    @discovery_thread.join

data/lib/roby/log/timings.rb

@@ -1,16 +1,16 @@
+require 'set'
+
 module Roby
     module Log
 	class Timings
 	    REF_TIMING = :start
 	    ALL_TIMINGS = [ :real_start, :events, 
 		:structure_check, :exception_propagation,
-		:exceptions_fatal, :garbage_collect, :application_errors, 
-		:expected_ruby_gc, :ruby_gc, :droby, :expected_sleep, :sleep, :end ]
+		:exceptions_fatal, :garbage_collect, 
+		:ruby_gc, :expected_sleep, :sleep, :end ]
 	
-	    NUMERIC_FIELDS = [:cycle_index, :live_objects, :object_allocation, :log_queue_size, :ruby_gc_duration, 
-		:plan_task_count, :plan_event_count]
-	    DELTAS = [:cpu_time]
-	    ALL_NUMERIC_FIELDS = NUMERIC_FIELDS + DELTAS
+	    ALL_NUMERIC_FIELDS = [:cycle_index, :live_objects, :object_allocation, :heap_slots,
+                :log_queue_size, :plan_task_count, :plan_event_count, :cpu_time]
 
 	    ALL_FIELDS = ALL_TIMINGS + ALL_NUMERIC_FIELDS + [:event_count, :pos]
 
@@ -23,7 +23,86 @@ module Roby
 	    end
 	    def rewind; logfile.rewind end
 
-	    def each_cycle(cumulative = false)
+            # Read the logfile index, extract statistic information from it and
+            # yield them cycle-by-cycle. The format of +timings+ is the
+            # following:
+            #
+            #   [start, real_start, events, 
+            #       structure_check, exception_propagation,
+            #       exceptions_fatal, garbage_collect,
+            #       ruby_gc, expected_sleep, sleep, end]
+            #
+            # where +start+ is the target start time of the cycle as a Time
+            # object. The rest of the values are floating-point values which
+            # represent offset from +start+ if +cumulative+ is true or offset
+            # from the previous one if +cumulative+ is false. Therefore, in the
+            # latter case, the values represent the actual duration of each
+            # phase in the execution engine.
+            #
+            # The phases are as follows:
+            # real_start::
+            #   the actual starting time. It allows to see the offset due (for
+            #   instance) to the uncertainty in sleep
+            # events::
+            #   event propagation phase, including the propagation of dRoby
+            #   events (events coming from remote hosts)
+            # structure_check::
+            #   first structure checking pass
+            # exception_propagation::
+            #   exception propagation phase
+            # exceptions_fatal::
+            #   second structure checking pass, and propagation of the fatal
+            #   errors (i.e. killing the involved tasks)
+            # garbage_collect::
+            #   Roby's garbage collection pass
+            # ruby_gc:: 
+            #   if GC.enable accepts a true/false argument, Roby will
+            #   explicitely allow the GC to run only at a specific point, and
+            #   monitor its execution time. This is the result.  Note that Roby
+            #   issues a warning at startup if it is not the case.
+            # expected_sleep:: 
+            #   how much time Roby wanted to sleep (i.e. how many milliseconds
+            #   were given to the sleep() call)
+            # sleep::
+            #   how much time Roby actually slept
+            # end::
+            #   end of the cycle
+            #
+            # The second array that is yield, +numeric+, contains non-timing
+            # statistics. Its format is:
+            #
+	    #   [cycle_index, live_objects, object_allocation, log_queue_size,
+	    #       plan_task_count, plan_event_count, cpu_time]
+            # 
+            # where
+            #
+            # cycle_index::
+            #   The index of this cycle. Note that some number can be missing: if one
+            #   cycle takes more than two time its allocated period, then +cycle_index+ is
+            #   updated to reflect the cycles that have been missed.
+            # live_objects:: 
+            #   The count of allocated objects at the end of the cycle. It is only valid
+            #   on Ruby interpreters that have been patched to report this value
+            #   efficiently.
+            # object_allocation::
+            #   How many objects have been allocated during this cycle. This is valid only
+            #   if Ruby GC is controlled by Roby (see the description of +ruby_gc+ above).
+            #   Otherwise, it will be invalid in cycles where the Ruby GC ran, as the
+            #   statistics can't correct the objects freed by Ruby's GC.
+            # log_queue_size::
+            #   The logger runs in a thread separated from the execution engine, and a
+            #   fixed-size queue is used to communicate between the threads. This value is
+            #   the size of the queue at the end of the cycle (after sleep()). It is
+            #   mainly used for debugging purposes: if this queue is almost full, then the
+            #   execution engine thread will probably be interrupted to let the log thread
+            #   empty the queue.
+            # plan_task_count::
+            #   The count of tasks in the plan at the end of the cycle.
+            # plan_event_count::
+            #   The count of free events in the plan at the end of the cycle.
+            # cpu_time::
+            #   The CPU time taken by the Roby controller for this cycle.
+	    def each_cycle(cumulative = false) # :yield:numeric, timings
 		last_deltas = Hash.new
 		for data in logfile.index_data[1..-1]
 		    result  = []
@@ -54,18 +133,8 @@ module Roby
 			end
 		    end
 
-		    numeric = data.values_at(*NUMERIC_FIELDS)
-		    deltas = DELTAS.map do |name|
-			value = if old_value = last_deltas[name]
-				    data[name] - old_value
-				else
-				    0
-				end
-			last_deltas[name] = data[name]
-			value
-		    end
-
-		    yield(numeric + deltas, result)
+		    numeric = data.values_at(*ALL_NUMERIC_FIELDS)
+		    yield(numeric, result)
 		end
 
 	    rescue ArgumentError => e

data/lib/roby/plan-object.rb

@@ -1,7 +1,3 @@
-require 'roby/relations'
-require 'roby/distributed/base'
-require 'roby/basic_object'
-
 module Roby
     # Base class for all objects which are included in a plan.
     class PlanObject < BasicObject
@@ -10,6 +6,9 @@ module Roby
 	# The plan this object belongs to
 	attr_reader :plan
 
+        # The engine which acts on +plan+ (if there is one)
+        def engine; plan.engine end
+
         # The place where this object has been removed from its plan. Once an
         # object is removed from its plan, it cannot be added back again.
 	attr_accessor :removed_at
@@ -29,6 +28,109 @@ module Roby
 	    @plan = new_plan
 	end
 
+        # The propagation engine object for this. For PlanObject instances, it
+        # is always the plan itself.
+        def propagation_engine
+            plan
+        end
+
+        # If +self+ is a transaction proxy, returns the underlying plan object,
+        # regardless of how many transactions there is on the stack. Otherwise,
+        # return self.
+        def real_object
+            result = self
+            while result.respond_to?(:__getobj__)
+                result = result.__getobj__
+            end
+            result
+        end
+
+        # Returns the stack of transactions/plans this object is part of,
+        # starting with self.plan.
+        def transaction_stack
+            result = [plan]
+            obj    = self
+            while obj.respond_to?(:__getobj__)
+                obj = obj.__getobj__
+                result << obj.plan
+            end
+            result
+        end
+
+        # call-seq:
+        #   merged_relation(:each_child_object, false, Dependency) do |parent, child|
+        #   end
+        #   merged_relation(:each_child_object, true, Dependency) do |child|
+        #   end
+        #
+        # Behaves like +enumerator+, but merges all the changes that underlying
+        # transactions may have applied. I.e. it is equivalent to applying
+        # +enumerator+ on the plan that would be the result of the application
+        # of the whole transaction stack
+        #
+        # If +instrusive+ is false, the edges are yielded at the level they
+        # appear. I.e. both the parent and the child are given, and [parent,
+        # child] may be part of a parent plan of self.plan.
+        #
+        # If +instrusive+ is true, the related objects are recursively added to
+        # all transactions in the transaction stack, and are given at the end.
+        # I.e. only the related object is yield, and it is guaranteed to be
+        # included in self.plan.
+        def merged_relations(enumerator, intrusive, *args, &block)
+            if !block_given?
+                return enum_for(:merged_relations, enumerator, intrusive, *args)
+            end
+
+            plan_chain = self.transaction_stack
+            object     = self.real_object
+
+            pending = Array.new
+            while plan_chain.size > 1
+                plan      = plan_chain.pop
+                next_plan = plan_chain.last
+
+                # Objects that are in +plan+ but not in +next_plan+ are
+                # automatically added, as +next_plan+ is not able to change
+                # them. Those that are included in +next_plan+ are handled
+                # later.
+                new_objects = Array.new
+                object.send(enumerator, *args) do |related_object, _|
+                    next if next_plan[related_object, false]
+
+                    if !intrusive
+                        yield(object, related_object)
+                    else
+                        new_objects   << related_object
+                    end
+                end
+
+                # Here, pending contains objects from the previous plan (i.e. in
+                # plan.plan). Proxy them in +plan+.
+                #
+                # It is important to do that *after* we enumerated the relations
+                # that exist in +plan+ (above), as it reduces the number of
+                # relations at each level.
+                pending.map! { |t| plan[t] }
+                # And add the new objects that we just discovered
+                pending.concat(new_objects)
+
+                if next_plan
+                    object = next_plan[object]
+                end
+            end
+
+            if intrusive
+                send(enumerator, *args, &block)
+                for related_object in pending
+                    yield(self.plan[related_object])
+                end
+            else
+                send(enumerator, *args) do |related_object, _|
+                    yield(self, related_object)
+                end
+            end
+        end
+
 	# A three-state flag with the following values:
 	# nil:: the object is executable if its plan is
 	# true:: the object is executable
@@ -68,9 +170,9 @@ module Roby
 	    elsif other.plan && plan
 		raise RuntimeError, "cannot add a relation between two objects from different plans. #{self} is from #{plan} and #{other} is from #{other.plan}"
 	    elsif plan
-		self.plan.discover(other)
+		self.plan.add(other)
 	    elsif other.plan
-		other.plan.discover(self)
+		other.plan.add(self)
 	    end
 	end
 	protected :synchronize_plan
@@ -233,15 +335,37 @@ module Roby
 	    end
 	end
 
-        # Checks if we have the right to remove a relation. Raises
-        # OwnershipError if it is not the case
-	def removing_child_object(child, type)
-	    super if defined? super
+        # Hook called when a new child is added to this object in the given
+        # relations and with the given information object.
+        def adding_child_object(child, relations, info)
+            super if defined? super
+            return if !plan
+
+            for trsc in plan.transactions
+                next unless trsc.proxying?
+                if (parent_proxy = trsc[self, false]) && (child_proxy = trsc[child, false])
+                    trsc.adding_plan_relation(parent_proxy, child_proxy, relations, info) 
+                end
+            end
+        end
 
+        # Hook called when a child of this object is being removed from the
+        # given relations.
+        def removing_child_object(child, relations)
 	    unless read_write? || child.read_write?
 		raise OwnershipError, "cannot remove a relation between two objects we don't own"
 	    end
-	end
+
+            super if defined? super
+            return if !plan
+
+            for trsc in plan.transactions
+                next unless trsc.proxying?
+                if (parent_proxy = trsc[self, false]) && (child_proxy = trsc[child, false])
+                    trsc.removing_plan_relation(parent_proxy, child_proxy, relations) 
+                end
+            end
+        end
     end
 end