roby 0.8.0 → 3.0.0

data/lib/roby/log/sqlite.rb

@@ -1,47 +0,0 @@
-require 'roby/log'
-require 'roby/distributed'
-require 'sqlite3'
-require 'stringio'
-
-module Roby::Log
-    class SQLiteLogger
-	attr_reader :db, :insert
-	def initialize(filename)
-	    @db = SQLite3::Database.new(filename)
-	    db.execute("DROP TABLE IF EXISTS events")
-	    db.execute("CREATE TABLE events (
-		       method TEXT,
-		       sec    INTEGER,
-		       usec   INTEGER,
-		       args   BLOB)")
-	    @insert = db.prepare("insert into events values (?, ?, ?, ?)")
-	end
-	def splat?; false end
-
-	Roby::Log.each_hook do |klass, m|
-	    define_method(m) do |args|
-		begin
-		    time = args[0]
-		    args = SQLite3::Blob.new Roby::Distributed.dump(args[1..-1])
-		    insert.execute(m.to_s, time.tv_sec, time.tv_usec, args)
-		rescue
-		    STDERR.puts "failed to dump #{m}#{args}: #{$!.full_message}"
-		end
-	    end
-	end
-
-	def self.replay(filename)
-	    db = SQLite3::Database.new(filename)
-	    method_name = nil
-	    db.execute("select * from events") do |method_name, sec, usec, args|
-		time = Time.at(Integer(sec), Integer(usec))
-		args = Marshal.load(StringIO.new(args))
-		args.unshift time
-		yield(method_name.to_sym, args)
-	    end
-	rescue
-	    STDERR.puts "ignoring call to #{method_name}: #{$!.full_message}"
-	end
-    end
-end
-

data/lib/roby/log/timings.rb

@@ -1,233 +0,0 @@
-require 'set'
-
-module Roby
-    module Log
-	class Timings
-	    REF_TIMING = :start
-	    ALL_TIMINGS = [ :real_start, :events, 
-		:structure_check, :exception_propagation,
-		:exceptions_fatal, :garbage_collect, 
-		:ruby_gc, :expected_sleep, :sleep, :end ]
-	
-	    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]
-
-	    attr_reader :logfile
-	    attr_reader :ignored_timings
-	    def initialize(logfile)
-		@logfile = logfile
-		@ignored_timings = Set.new
-		rewind
-	    end
-	    def rewind; logfile.rewind end
-
-            # 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  = []
-		    timings = data
-		    ref     = Time.at(*timings.delete(REF_TIMING))
-		    result  << ref
-
-		    unknown_timings = (timings.keys.to_set - ALL_FIELDS.to_set - ignored_timings)
-		    if !unknown_timings.empty?
-			STDERR.puts "ignoring the following timings: #{unknown_timings.to_a.join(", ")}"
-			@ignored_timings |= unknown_timings
-		    end
-		    timings = ALL_TIMINGS.map do |name|
-			timings[name]
-		    end
-
-		    if cumulative
-			timings.inject(0) do |last, time| 
-			    time ||= last
-			    result << time
-			    time
-			end
-		    else
-			timings.inject(0) do |last, time| 
-			    time ||= last
-			    result << time - last
-			    time
-			end
-		    end
-
-		    numeric = data.values_at(*ALL_NUMERIC_FIELDS)
-		    yield(numeric, result)
-		end
-
-	    rescue ArgumentError => e
-		if e.message =~ /marshal data too short/
-		    STDERR.puts "File truncated"
-		else raise
-		end
-	    end
-
-	    def timeval_to_s(t)
-		'%02i:%02i:%02i.%03i' % [t.tv_sec / 3600, t.tv_sec % 3600 / 60, t.tv_sec % 60, t.tv_usec / 1000]
-	    end
-
-	    def stats
-		last_start = nil
-		mean, max, stdev = nil
-		count = 0
-
-		mean_cycle  = 0
-		stdev_cycle = 0
-		max_cycle   = nil
-
-		# Compute mean value
-		each_cycle(false) do |numeric, timings|
-		    if !mean
-			mean  = Array.new(numeric.size + timings.size, 0.0)
-			max   = Array.new
-		    end
-
-		    # Compute mean value
-		    start = timings.shift + timings.first
-		    if last_start
-			cycle_length = start - last_start
-			if !max_cycle || max_cycle < cycle_length
-			    max_cycle = cycle_length
-			end
-			mean_cycle += cycle_length
-		    end
-		    last_start = start 
-
-		    (numeric + timings).each_with_index do |v, i| 
-			mean[i] += v if v
-			max[i] = v if v && (!max[i] || max[i] < v)
-		    end
-		    count += 1
-		end
-		mean.map! { |v| v / count }
-		mean_cycle /= count
-
-		last_start = nil
-		rewind
-		stdev = Array.new(mean.size, 0.0)
-		each_cycle(false) do |numeric, timings|
-		    start = timings.shift + timings.first
-		    if last_start
-			stdev_cycle += (start - last_start - mean_cycle)**2
-		    end
-		    last_start = start
-
-		    (numeric + timings).each_with_index { |v, i| stdev[i] += (v - mean[i]) ** 2 if v }
-		end
-		stdev.map! { |v| Math.sqrt(v / count) if v }
-
-		format = "%-28s %-10.2f %-10.2f %-10.2f"
-
-		puts "\n" + "Per-cycle statistics".center(50)
-		puts "%-28s %-10s %-10s %-10s" % ['', 'mean', 'stddev', 'max']
-		puts format % ["cycle", mean_cycle * 1000, Math.sqrt(stdev_cycle / count) * 1000, max_cycle * 1000]
-		ALL_NUMERIC_FIELDS.each_with_index do |name, i|
-		    puts format % [name, mean[i], stdev[i], (max[i] || 0)] unless name == :cycle_index
-		end
-
-		puts "\n" + "Broken down cycle timings".center(50)
-		puts "%-28s %-10s %-10s %-10s" % ['', 'mean', 'stddev', 'max']
-		(ALL_TIMINGS).each_with_index do |name, i|
-		    i += ALL_NUMERIC_FIELDS.size
-		    puts format % [name, mean[i] * 1000, stdev[i] * 1000, max[i] * 1000]
-		end
-	    end
-
-	    def display(cumulative)
-		header = ([REF_TIMING] + ALL_TIMINGS + ALL_NUMERIC_FIELDS).enum_for(:each_with_index).
-		    map { |n, i| "#{i + 1}_#{n}" }.
-		    join("\t")
-
-		puts header
-		each_cycle(cumulative) do |numeric, results|
-		    print "#{timeval_to_s(results.shift)} "
-		    print results.join(" ")
-		    print " "
-		    puts numeric.join(" ")
-		end
-	    end
-	end
-    end
-end

data/lib/roby/plan-object.rb

@@ -1,371 +0,0 @@
-module Roby
-    # Base class for all objects which are included in a plan.
-    class PlanObject < BasicObject
-	include DirectedRelationSupport
-
-	# 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
-
-        # True if this object has been included in a plan, but has been removed
-        # from it since
-	def finalized?; !!removed_at end
-
-	# Sets the new plan. Since it is forbidden to re-use a plan object that
-	# has been removed from a plan, it raises ArgumentError if it is the
-	# case
-	def plan=(new_plan)
-	    if removed_at
-		raise ArgumentError, "#{self} has been removed from plan, cannot add it back\n" +
-		    "Removed at\n  #{removed_at.join("\n  ")}"
-	    end
-	    @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
-	# false:: the object is not executable
-	attr_writer :executable
-
-	# If this object is executable
-	def executable?
-	    @executable || (@executable.nil? && plan && plan.executable?)
-	end
-
-	# True if we are explicitely subscribed to this object
-	def subscribed?
-	    if root_object?
-		(plan && plan.subscribed?) ||
-		    (!self_owned? && owners.any? { |peer| peer.subscribed_plan? }) ||
-		    super
-	    else
-		root_object.subscribed?
-	    end
-	end
-
-        # True if we should send updates about this object to +peer+
-	def update_on?(peer); (plan && plan.update_on?(peer)) || super end
-        # True if we receive updates for this object from +peer+
-	def updated_by?(peer); (plan && plan.updated_by?(peer)) || super end
-        # True if this object is useful for one of our peers
-	def remotely_useful?; (plan && plan.remotely_useful?) || super end
-
-        # Checks that we do not link two objects from two different plans and
-        # updates the +plan+ attribute accordingly
-        #
-        # It raises RuntimeError if both objects are already included in a
-        # plan, but their plan mismatches.
-	def synchronize_plan(other) # :nodoc:
-	    if plan == other.plan
-	    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.add(other)
-	    elsif other.plan
-		other.plan.add(self)
-	    end
-	end
-	protected :synchronize_plan
-
-        # Called when all links to +peer+ should be removed.
-	def forget_peer(peer)
-	    if !root_object?
-		raise ArgumentError, "#{self} is not root"
-	    end
-
-	    each_plan_child do |child|
-		child.forget_peer(peer)
-	    end
-	    super
-	end
-
-        # Synchronizes the plan of this object from the one of its peer
-	def add_child_object(child, type, info = nil) # :nodoc:
-	    if child.plan != plan
-		root_object.synchronize_plan(child.root_object)
-	    end
-
-	    super
-	end
-
-        # Return the root plan object for this object.
-	def root_object; self end
-        # True if this object is a root object in the plan.
-	def root_object?; root_object == self end
-        # Iterates on all the children of this root object
-	def each_plan_child; self end
-
-        # This class method sets up the enclosing class as a child object,
-        # with the root object being returned by the given attribute.
-        # Task event generators are for instance defined by
-        #
-        #   class TaskEventGenerator < EventGenerator
-        #       # The task this generator belongs to
-        #       attr_reader :task
-        #
-        #       child_plan_object :task
-        #   end
-	def self.child_plan_object(attribute)
-	    class_eval <<-EOD
-	    def root_object; #{attribute} end
-	    def root_object?; false end
-	    def owners; #{attribute}.owners end
-	    def distribute?; #{attribute}.distribute? end
-	    def plan; #{attribute}.plan end
-	    def executable?; #{attribute}.executable? end
-
-	    def subscribed?; #{attribute}.subscribed? end
-	    def updated?; #{attribute}.updated? end
-	    def updated_by?(peer); #{attribute}.updated_by?(peer) end
-	    def update_on?(peer); #{attribute}.update_on?(peer) end
-	    def updated_peers; #{attribute}.updated_peers end
-	    def remotely_useful?; #{attribute}.remotely_useful? end
-
-	    def forget_peer(peer)
-		remove_sibling_for(peer)
-	    end
-	    def sibling_of(remote_object, peer)
-		if !distribute?
-		    raise ArgumentError, "#{self} is local only"
-		end
-
-		add_sibling_for(peer, remote_object)
-	    end
-	
-	    private :plan=
-	    private :executable=
-	    EOD
-	end
-
-        # Transfers a set of relations from this plan object to +object+.
-        # +changes+ is formatted as a sequence of <tt>relation, parents,
-        # children</tt> slices, where +parents+ and +children+ are sets of
-        # objects.
-        #
-        # For each of these slices, the method removes the
-        # <tt>parent->self</tt> and <tt>self->child</tt> edges in the given
-        # relation, and then adds the corresponding <tt>parent->object</tt> and
-        # <tt>object->child</tt> edges.
-	def apply_relation_changes(object, changes)
-            # The operation is done in two parts to avoid problems with
-            # creating cycles in the graph: first we remove the old edges, then
-            # we add the new ones.
-	    changes.each_slice(3) do |rel, parents, children|
-		parents.each_slice(2) do |parent, info|
-		    parent.remove_child_object(self, rel)
-		end
-		children.each_slice(2) do |child, info|
-		    remove_child_object(child, rel)
-		end
-	    end
-
-	    changes.each_slice(3) do |rel, parents, children|
-		parents.each_slice(2) do |parent, info|
-		    parent.add_child_object(object, rel, info)
-		end
-		children.each_slice(2) do |child, info|
-		    object.add_child_object(child, rel, info)
-		end
-	    end
-	end
-
-        # Replaces, in the plan, the subplan generated by this plan object by
-        # the one generated by +object+. In practice, it means that we transfer
-        # all parent edges whose target is +self+ from the receiver to
-        # +object+. It calls the various add/remove hooks defined in
-        # DirectedRelationSupport.
-	def replace_subplan_by(object)
-	    changes = []
-	    each_relation do |rel|
-		parents = []
-		each_parent_object(rel) do |parent|
-		    unless parent.root_object == root_object
-			parents << parent << parent[self, rel]
-		    end
-		end
-		changes << rel << parents << []
-	    end
-
-	    apply_relation_changes(object, changes)
-	end
-
-        # Replaces +self+ by +object+ in all graphs +self+ is part of. Unlike
-        # BGL::Vertex#replace_by, this calls the various add/remove hooks
-        # defined in DirectedRelationSupport
-	def replace_by(object)
-	    changes = []
-	    each_relation do |rel|
-		parents = []
-		each_parent_object(rel) do |parent|
-		    unless parent.root_object == root_object
-			parents << parent << parent[self, rel]
-		    end
-		end
-		children = []
-		each_child_object(rel) do |child|
-		    unless child.root_object == root_object
-			children << child << self[child, rel]
-		    end
-		end
-		changes << rel << parents << children
-	    end
-
-	    apply_relation_changes(object, changes)
-	end
-
-        # True if this object can be modified by the local plan manager
-	def read_write?
-	    if (owners.include?(Distributed) || Distributed.updating?(root_object) || !plan)
-		true
-	    elsif plan.owners.include?(Distributed)
-		for peer in owners
-		    return false unless plan.owners.include?(peer)
-		end
-		true
-	    end
-	end
-
-        # 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
-
-            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
-