roby 0.8.0 → 3.0.0

data/lib/roby/droby/remote_droby_id.rb

@@ -0,0 +1,6 @@
+module Roby
+    module DRoby
+        RemoteDRobyID = V5::RemoteDRobyID
+    end
+end
+

data/lib/roby/droby/timepoints.rb

@@ -0,0 +1,205 @@
+require 'json'
+
+module Roby
+    module DRoby
+        module Timepoints
+            class Analysis
+                attr_reader :roots
+                attr_reader :thread_names
+                attr_reader :current_groups
+
+                def initialize
+                    @thread_names = Hash.new
+                    @roots = roots = Hash.new
+                    @current_groups = Hash.new do |h, thread_id|
+                        roots[thread_id] = h[thread_id] = Root.new(thread_id)
+                    end
+                end
+
+                def add(time, thread_id, thread_name, name)
+                    thread_names[thread_id] ||= thread_name
+                    current_groups[thread_id].add(time, name)
+                end
+
+                def group_start(time, thread_id, thread_name, name)
+                    thread_names[thread_id] ||= thread_name
+                    @current_groups[thread_id] = current_groups[thread_id].group_start(time, name)
+                end
+
+                def group_end(time, thread_id, thread_name, name)
+                    thread_names[thread_id] ||= thread_name
+                    current_g = current_groups[thread_id]
+                    if current_g == roots[thread_id]
+                        raise ArgumentError, "called #group_end on the root group"
+                    elsif name != current_g.name
+                        raise ArgumentError, "mismatching name in #group_end"
+                    end
+
+                    current_g = @current_groups[thread_id] = current_g.group
+                    current_g.group_end(time)
+                end
+
+                def flamegraph
+                    raw = roots.each_value.map do |root|
+                        root.flamegraph
+                    end
+                    folded = Hash.new(0)
+                    raw.each_slice(2) do |path, value|
+                        folded[path] += value
+                    end
+                    folded.to_a.sort
+                end
+
+                def format(indent: 0, base_time: roots.each_value.map(&:start_time).min, absolute_times: true)
+                    roots.each_value.map do |root|
+                        root.format(indent: indent, base_time: base_time, absolute_times: absolute_times).
+                            join("\n")
+                    end.join("\n")
+                end
+            end
+
+            class Point
+                attr_reader :group
+                attr_reader :name
+                attr_reader :time
+                attr_reader :duration
+                
+                def initialize(time, name, duration, group)
+                    @time = time
+                    @name = name
+                    @duration = duration
+                    @group = group
+                end
+                
+                def path
+                    group.path + [name]
+                end
+
+                def flamegraph
+                    [path, duration]
+                end
+
+                def start_time; time end
+                def end_time; time end
+            end
+
+            class Aggregate
+                attr_reader :current_time
+                attr_reader :timepoints
+
+                def initialize
+                    @timepoints = Array.new
+                end
+
+                def start_time
+                    timepoints.first.start_time
+                end
+
+                def end_time
+                    timepoints.last.end_time
+                end
+
+                def duration
+                    end_time - start_time
+                end
+
+                def add(time, name)
+                    timepoints << Point.new(time, name, time - (current_time || time), self)
+                    @current_time = time
+                end
+
+                def group_start(time, name)
+                    group = Group.new(time, name, self)
+                    timepoints << group
+                    group
+                end
+
+                def group_end(time)
+                    timepoints.last.close(time)
+                    @current_time = time
+                end
+                
+                def format(indent: 0, last_time: start_time, base_time: start_time, absolute_times: true)
+                    start_format = "%5.3f %5.3f       #{" " * indent}%s"
+                    end_format   = "%5.3f %5.3f %5.3f #{" " * indent}%s"
+                    line_format  = "%5.3f %5.3f       #{" " * indent}  %s"
+
+                    result = Array.new
+                    result << start_format % [start_time - base_time, start_time - last_time, "#{name}:start"]
+
+                    last_time = timepoints.inject(last_time) do |last, tp|
+                        if tp.respond_to?(:format)
+                            result.concat(tp.format(last_time: last, indent: indent + 2, base_time: base_time, absolute_times: absolute_times))
+                            tp.end_time
+                        else
+                            result << line_format % [tp.time - base_time, tp.time - last, tp.name]
+                            tp.time
+                        end
+                    end
+
+                    result << end_format   % [end_time - base_time, end_time - last_time, duration, "#{name}:end"]
+                    result
+                end
+                
+                def path
+                    [name]
+                end
+
+                def flamegraph
+                    result = Array.new
+                    duration = timepoints.inject(0) do |d, tp|
+                        result.concat(tp.flamegraph)
+                        d + tp.duration
+                    end
+                    result << path << self.duration - duration
+                    result
+                end
+            end
+
+            class Root < Aggregate
+                attr_reader :name
+                attr_reader :level
+
+                def initialize(name = 'root')
+                    super()
+
+                    @name = name
+                    @level = 0
+                end
+            end
+
+            class Group < Aggregate
+                attr_reader :name
+                attr_reader :level
+                attr_reader :group
+
+                attr_reader :start_time
+                attr_reader :end_time
+
+                def initialize(time, name, group)
+                    super()
+
+                    @name  = name
+                    @group = group
+                    @level = group.level + 1
+
+                    @current_time = time
+                    @start_time = time
+                end
+
+                def path
+                    @path ||= (group.path + [name])
+                end
+
+                def end_time
+                    current_time
+                end
+
+                def close(time)
+                    @current_time = time
+                end
+            end
+        end
+    end
+end
+

data/lib/roby/droby/timepoints_ctf.metadata.erb

@@ -0,0 +1,101 @@
+/* CTF 1.8 */
+
+typealias integer { size = 8; align = 8; signed = false; } := uint8_t;
+typealias integer { size = 16; align = 8; signed = false; } := uint16_t;
+typealias integer { size = 32; align = 8; signed = false; } := uint32_t;
+typealias integer { size = 64; align = 8; signed = false; } := uint64_t;
+typealias integer { size = 64; align = 8; signed = false; } := unsigned long;
+
+trace {
+    major = 2;
+    minor = 0;
+    uuid = "<%= _uuid_s %>";
+    byte_order = le;
+    packet.header := struct {
+        uint32_t magic;
+        uint8_t  uuid[16];
+        uint32_t stream_id;
+    };
+};
+
+env {
+    domain = "ust";
+};
+
+clock {
+    name = wall;
+    freq = 1000000;           /* microseconds */
+    offset_s = <%= _clock_base %>;
+};
+
+typealias integer {
+    size = 32; align = 8; signed = false;
+    map = clock.wall.value;
+} := uint32_wallclock_t;
+
+typealias integer {
+    size = 64; align = 8; signed = false;
+    map = clock.wall.value;
+} := uint64_wallclock_t;
+
+struct packet_context {
+    uint64_t timestamp_begin;
+    uint64_t timestamp_end;
+    uint32_t cpu_id;
+} align(8);
+
+struct event_header {
+    /*
+     * id: range: 0 - 65534.
+     * id 65535 is reserved to indicate an extended header.
+     */
+    enum : uint16_t { compact = 0 ... 65534, extended = 65535 } id;
+    variant <id> {
+        struct {
+            uint32_wallclock_t timestamp;
+        } compact;
+        struct {
+            uint32_t id;        /* 32-bit event IDs */
+            uint64_wallclock_t timestamp; /* 64-bit timestamps */
+        } extended;
+    } v;
+} align(8);
+
+stream {
+    id = 0;
+    packet.context := struct packet_context;
+    event.header := struct event_header;
+    event.context := struct {
+        uint32_t _vtid;
+        integer { size = 16; align = 8; signed = false; } __procname_length;
+        integer { size = 8; align = 8; signed = 1; encoding = UTF8; } _procname[__procname_length];
+        integer { size = 16; align = 8; signed = false; } __name_length;
+        integer { size = 8; align = 8; signed = 1; encoding = UTF8; } _name[__name_length];
+    };
+};
+
+event {
+    name = "event";
+    id = 1;
+    stream_id = 0;
+    fields := struct {
+    };
+};
+
+event {
+    name = "lttng_ust_cyg_profile_fast:func_entry";
+    id = 2;
+    stream_id = 0;
+    fields := struct {
+        uint32_t _addr;
+    };
+};
+
+event {
+    name = "lttng_ust_cyg_profile_fast:func_exit";
+    id = 3;
+    stream_id = 0;
+    fields := struct {
+    };
+};
+

data/lib/roby/droby/timepoints_ctf.rb

@@ -0,0 +1,125 @@
+require 'securerandom'
+
+module Roby
+    module DRoby
+        module Timepoints
+            class CTF
+                attr_reader :uuid
+                attr_reader :clock_base
+                attr_reader :name_to_addr_mapping
+
+                attr_reader :packet_timestamp_begin
+                attr_reader :packet_timestamp_end
+                attr_reader :packet_contents
+
+                attr_reader :thread_ids
+
+                def initialize(clock_base: 0)
+                    @uuid = SecureRandom.random_bytes(16).unpack("C*")
+                    @clock_base = clock_base
+
+                    @packet_timestamp_begin = nil
+                    @packet_timestamp_end = nil
+                    @packet_contents = String.new
+                    @name_to_addr_mapping = Hash.new
+
+                    @thread_ids = Hash.new
+                end
+
+                def make_timestamp(time)
+                    (time.tv_sec - clock_base) * 1_000_000 + time.tv_usec
+                end
+
+                def addr_from_name(name)
+                    name_to_addr_mapping[name] ||= name_to_addr_mapping.size
+                end
+
+                ID_TIMEPOINT = 1
+                ID_GROUP_START = 2
+                ID_GROUP_END = 3
+
+                def update_packet(time, marshalled_event)
+                    @packet_timestamp_begin ||= time
+                    @packet_timestamp_end = time
+                    packet_contents << marshalled_event
+                end
+
+                def thread_id_of(thread_id)
+                    if id = thread_ids[thread_id]
+                        id
+                    else
+                        thread_ids[thread_id] = thread_ids.size
+                    end
+                end
+
+                def group_start(time, thread_id, thread_name, name)
+                    marshalled = marshal_event(time, ID_GROUP_START, thread_id_of(thread_id), thread_name, name)
+                    update_packet(time, marshalled + [addr_from_name(name)].pack("L<"))
+                end
+
+                def group_end(time, thread_id, thread_name, name)
+                    update_packet(time, marshal_event(time, ID_GROUP_END, thread_id_of(thread_id), thread_name, name))
+                end
+
+                def add(time, thread_id, thread_name, name)
+                    update_packet(time, marshal_event(time, ID_TIMEPOINT, thread_id_of(thread_id), thread_name, name))
+                end
+
+                def self.generate_metadata(path, _uuid, _clock_base)
+                    _uuid_s = _uuid.map { |v| "%02x" % v }.join
+                    _uuid_s = "#{_uuid_s[0, 8]}-#{_uuid_s[8, 4]}-#{_uuid_s[12, 4]}-#{_uuid_s[16, 4]}-#{_uuid_s[20, 12]}"
+                    ERB.new(path.read).result(binding)
+                end
+
+                def metadata_template_path
+                    Pathname.new(__FILE__).dirname + "timepoints_ctf.metadata.erb"
+                end
+
+                def generate_metadata
+                    self.class.generate_metadata(metadata_template_path, uuid, clock_base)
+                end
+
+                def marshal_event(time, event_id, thread_id, thread_name, name)
+                    timestamp = make_timestamp(time)
+                    event_header  = [0xFFFF, event_id, make_timestamp(time)].pack("S<L<Q<")
+                    thread_name ||= ''
+                    event_context = [thread_id, thread_name.size, thread_name, name.size, name].pack("L<S<A#{thread_name.size}S<A#{name.size}")
+                    event_header + event_context
+                end
+
+                def marshal_packet
+                    header = [
+                        0xC1FC1FC1, # Magic
+                        *uuid,
+                        0 # Stream ID
+                    ].pack("L<C16L<")
+                    contents = packet_contents
+                    context = [
+                        make_timestamp(packet_timestamp_begin),
+                        make_timestamp(packet_timestamp_end),
+                        0].pack("Q<Q<L<")
+
+                    @packet_timestamp_begin = nil
+                    @packet_timestamp_end = nil
+                    @packet_contents = String.new
+                    header + context + contents
+                end
+
+                def save(path)
+                    (path + "metadata").open('w') do |io|
+                        io.write generate_metadata
+                    end
+                    (path + "channel0_0").open('w') do |io|
+                        io.write marshal_packet
+                    end
+                    path.sub_ext('.ctf.names').open('w') do |io|
+                        name_to_addr_mapping.each do |name, id|
+                            io.puts("%016x T %s" % [id, name.gsub(/[^\w]/, '_')])
+                        end
+                    end
+                end
+            end
+        end
+    end
+end
+

data/lib/roby/droby/v5.rb

@@ -0,0 +1,14 @@
+require 'roby/droby/exceptions'
+require 'roby/droby/object_manager'
+require 'roby/droby/marshal'
+
+require 'roby/droby/v5/droby_id'
+require 'roby/droby/v5/peer_id'
+require 'roby/droby/v5/remote_droby_id'
+
+require 'roby/droby/v5/droby_constant'
+require 'roby/droby/v5/droby_model'
+require 'roby/droby/v5/droby_class'
+
+require 'roby/droby/v5/builtin'
+require 'roby/droby/v5/droby_dump'