roby 0.7

data/lib/roby/log/sqlite.rb

@@ -0,0 +1,47 @@
+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

@@ -0,0 +1,164 @@
+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 ]
+	
+	    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_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
+
+	    def each_cycle(cumulative = false)
+		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(*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)
+		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

@@ -0,0 +1,247 @@
+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
+	include DirectedRelationSupport
+
+	# The plan this object belongs to
+	attr_reader :plan
+
+        # 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
+
+	# 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.discover(other)
+	    elsif other.plan
+		other.plan.discover(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
+
+        # 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
+
+	    unless read_write? || child.read_write?
+		raise OwnershipError, "cannot remove a relation between two objects we don't own"
+	    end
+	end
+    end
+end
+