babeltrace 0.1.0

data/lib/babeltrace/ctf/iterator.rb

@@ -0,0 +1,90 @@
+module Babeltrace
+  module CTF
+    class Trace
+      def iter_create(begin_pos: nil, end_pos: nil)
+        CTF.bt_ctf_iter_create(@context, begin_pos, end_pos)
+      end
+
+      def iter_create_intersect
+        begin_pos_ptr = FFI::MemoryPointer::new(:pointer)
+        end_pos_ptr = FFI::MemoryPointer::new(:pointer)
+        iter = CTF.bt_ctf_iter_create_intersect(@context, begin_pos_ptr, end_pos_ptr)
+        begin_pos = IterPosManaged::new(begin_pos_ptr.read_pointer)
+        end_pos = IterPosManaged::new(end_pos_ptr.read_pointer)
+        [iter, begin_pos, end_pos]
+      end
+    end
+
+    class Iter
+      def self.release(ptr)
+        CTF.bt_ctf_iter_destroy(ptr)
+      end
+
+      def get_iter
+        return @iter if @iter
+        @iter = CTF.bt_ctf_get_iter(self)
+        @iter.child = self
+        @iter
+      end
+
+      def read_event
+        CTF.bt_ctf_iter_read_event(self)
+      end
+
+      def read_event_flag
+        ptr = FFI::MemoryPointer::new(:int)
+        event = CTF.bt_ctf_iter_read_event_flags(self, ptr)
+        flags = ptr.read(:int)
+        [event, flags]
+      end
+
+      def get_lost_events_count
+        CTF.bt_ctf_get_lost_events_count(self)
+      end
+
+      def next
+        get_iter.next
+      end
+
+      def get_pos
+        get_iter.get_pos
+      end
+
+      def set_pos(pos)
+        get_iter.set_pos(pos)
+      end
+
+      def rewind
+        get_iter.rewind
+      end
+
+      def create_time_pos(timestamp)
+        get_iter.create_time_pos(timestamp)
+      end
+
+      def each
+        rewind
+        if block_given?
+          loop do
+            e = self.read_event
+            break if e.pointer.null?
+            yield e
+            r = self.next
+            break if r != 0
+          end
+	else
+          return to_enum(:each)
+        end
+      end
+
+    end
+
+    attach_function :bt_ctf_iter_create, [Context, :pointer, :pointer], Iter.by_ref #pointers to IterPos or IterPosManaged
+    attach_function :bt_ctf_iter_create_intersect, [Context, :pointer, :pointer], Iter.by_ref
+    attach_function :bt_ctf_get_iter, [Iter], Babeltrace::Iter.by_ref
+    attach_function :bt_ctf_iter_destroy, [Iter], :void
+    attach_function :bt_ctf_iter_read_event, [Iter], Event.by_ref
+    attach_function :bt_ctf_iter_read_event_flags, [Iter, :pointer], Event.by_ref
+    attach_function :bt_ctf_get_lost_events_count, [Iter], :uint64
+  end
+end

data/lib/babeltrace/format.rb

@@ -0,0 +1,54 @@
+module Babeltrace
+  class Context < FFI::ManagedStruct
+    layout :dummy, :pointer
+  end
+
+  class StreamPos < FFI::Struct
+    layout :dummy, :pointer
+  end
+
+  class MmapStream < FFI::Struct
+    layout :fd, :int,
+           :list, ListHead,
+           :priv, :pointer
+  end
+
+  class MmapStreamList < FFI::Struct
+    layout :head, ListHead
+  end
+
+  class TraceDescriptor < FFI::Struct
+    layout :dummy, :pointer
+  end
+
+  class TraceHandle < FFI::Struct
+    layout :dummy, :pointer
+  end
+
+  callback :packet_seek_callback, [StreamPos, :size_t, :int], :void
+  callback :open_trace_callback, [:string, :int, :packet_seek_callback, :pointer], TraceDescriptor.by_ref
+  callback :open_mmap_trace_callback, [MmapStreamList, :packet_seek_callback, :pointer], TraceDescriptor.by_ref
+  callback :close_trace_callback, [TraceDescriptor], :int
+  callback :set_context_callback, [TraceDescriptor, Context], :void
+  callback :set_handle_callback, [TraceDescriptor, TraceHandle], :void
+  callback :timestamp_begin_callback, [TraceDescriptor, TraceHandle, ClockType], :uint64
+  callback :timestamp_end_callback, [TraceDescriptor, TraceHandle, ClockType], :uint64
+  callback :convert_index_timestamp_callback, [TraceDescriptor], :int
+
+  class Format < FFI::Struct
+    layout :name, :intern_str,
+           :open_trace, :open_trace_callback,
+           :open_mmap_trace, :open_mmap_trace_callback,
+           :close_trace, :close_trace_callback,
+           :set_context, :set_context_callback,
+           :set_handle, :set_handle_callback,
+           :timestamp_begin, :timestamp_begin_callback,
+           :timestamp_end, :timestamp_end_callback,
+           :convert_index_timestamp, :convert_index_timestamp_callback
+  end
+
+  attach_function :bt_lookup_format, [:intern_str], Format
+  attach_function :bt_fprintf_format_list, [:pointer], :int
+  attach_function :bt_register_format, [Format], :int
+  attach_function :bt_unregister_format, [Format], :void
+end

data/lib/babeltrace/iterator.rb

@@ -0,0 +1,62 @@
+module Babeltrace
+  IterPosType = enum :SEEK_TIME, :SEEK_RESTORE, :SEEK_CUR, :SEEK_BEGIN, :SEEK_LAST
+
+  class SavedPos < FFI::Struct
+    layout :dummy, :pointer
+  end
+
+  class IterPos < FFI::Struct
+    class SeekUnion < FFI::Union
+      layout :seek_time, :uint64,
+             :restore, SavedPos.ptr
+    end
+    layout :type, IterPosType,
+           :u, SeekUnion
+  end
+
+  class IterPosManaged < FFI::ManagedStruct
+    class SeekUnion < FFI::Union
+      layout :seek_time, :uint64,
+             :restore, SavedPos.ptr
+    end
+    layout :type, IterPosType,
+           :u, SeekUnion
+
+    def self.release(ptr)
+      Babeltrace.bt_iter_free_pos(ptr)
+    end
+  end
+
+  class Iter < FFI::Struct
+    layout :dummy, :pointer
+    attr_accessor :child
+
+    def next
+      Babeltrace.bt_iter_next(self)
+    end
+
+    def get_pos
+      Babeltrace.bt_iter_get_pos(self)
+    end
+
+    def set_pos(pos)
+      Babeltrace.bt_iter_set_pos(self, pos)
+    end
+
+    def rewind
+      pos = IterPos::new
+      pos[:type] = :SEEK_BEGIN
+      set_pos(pos)
+    end
+
+    def create_time_pos(timestamp)
+      Babeltrace.bt_iter_create_time_pos(self, timestamp)
+    end
+  end
+
+  attach_function :bt_iter_next, [Iter], :int
+  attach_function :bt_iter_get_pos, [Iter], IterPosManaged.by_ref
+  attach_function :bt_iter_free_pos, [IterPosManaged], :void
+  attach_function :bt_iter_set_pos, [Iter, :pointer], :int #pointer to IterPos or IterPosManaged
+  attach_function :bt_iter_create_time_pos, [Iter, :uint64], IterPosManaged.by_ref
+end

data/lib/babeltrace/list.rb

@@ -0,0 +1,72 @@
+module Babeltrace
+
+  class ListHead < FFI::Struct
+    layout :next, ListHead.ptr,
+           :prev, ListHead.ptr
+
+    def init
+      self[:next] = self[:prev] = self
+      self
+    end
+
+    def add(head)
+      head[:next][:prev] = self
+      self[:next] = head[:next]
+      self[:prev] = head
+      head[:next] = self
+      self
+    end
+
+    def add_tail(head)
+      head[:prev][:next] = self
+      self[:next] = head
+      self[:prev] = head[:prev]
+      head[:prev] = self
+      self
+    end
+
+    def self.del(p, n)
+      n[:prev] = p
+      n[:next] = n
+    end
+
+    def del
+      ListHead.del(self[:prev], self[:next])
+      self
+    end
+
+    def move(list)
+      ListHead.del(self[:prev], self[:next])
+      self.add(list)
+      self
+    end
+
+    def replace(n)
+      n[:next] = self[:next]
+      n[:prev] = self[:prev]
+      n[:prev][:next] = n
+      n[:next][:prev] = n
+      self
+    end
+
+    def splice(head)
+      if(!empty?)
+        self[:next][:prev] = head
+        self[:prev][:next] = head[:next]
+        head[:next][:prev] = self[:prev]
+        head[:next] = self[:next]
+      end
+    end
+
+    def empty?
+      self.to_ptr == self[:next].to_ptr
+    end
+
+    def replace_init(n)
+      head = self[:next]
+      self.del
+      n.add_tail(head)
+      self.init
+    end
+  end
+end

data/lib/babeltrace/trace_handle.rb

@@ -0,0 +1,28 @@
+module Babeltrace
+  class Trace
+    attr_reader :context
+    attr_reader :handle_id
+    def initialize(context, handle_id)
+      @context = context
+      @handle_id = handle_id
+    end
+
+    def get_path
+      Babeltrace.bt_trace_handle_get_path(@context, @handle_id)
+    end
+
+    def get_timestamp_begin(clock_type = :REAL)
+      t = Babeltrace.bt_trace_handle_get_timestamp_begin(@context, @handle_id, clock_type)
+      t = Time.at(0, t, :nsec) if clock_type == :REAL
+    end
+
+    def get_timestamp_end(clock_type = :REAL)
+      t = Babeltrace.bt_trace_handle_get_timestamp_end(@context, @handle_id, clock_type)
+      t = Time.at(0, t, :nsec) if clock_type == :REAL
+    end
+  end
+
+  attach_function :bt_trace_handle_get_path, [Context, :int], :string
+  attach_function :bt_trace_handle_get_timestamp_begin, [Context, :int, ClockType], :uint64
+  attach_function :bt_trace_handle_get_timestamp_end, [Context, :int, ClockType], :uint64
+end

data/lib/babeltrace/types.rb

@@ -0,0 +1,8 @@
+module Babeltrace
+
+  TYPES = [[:int, :intern_str]]
+  TYPES.each { |orig, add|
+    typedef orig, add
+  }
+
+end

metadata

@@ -0,0 +1,83 @@
+--- !ruby/object:Gem::Specification
+name: babeltrace
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Brice Videau
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-10-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ffi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.9.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.9.3
+description: Ruby libbabeltrace ffi bindings
+email: bvideau@anl.gov
+executables: []
+extensions:
+- ext/babeltrace_c/extconf.rb
+extra_rdoc_files: []
+files:
+- LICENSE
+- babeltrace.gemspec
+- ext/babeltrace_c/babeltrace.c
+- ext/babeltrace_c/babeltrace/align.h
+- ext/babeltrace_c/babeltrace/compiler.h
+- ext/babeltrace_c/babeltrace/types.h
+- ext/babeltrace_c/extconf.rb
+- lib/babeltrace.rb
+- lib/babeltrace/clock_type.rb
+- lib/babeltrace/context.rb
+- lib/babeltrace/ctf.rb
+- lib/babeltrace/ctf/callbacks.rb
+- lib/babeltrace/ctf/events.rb
+- lib/babeltrace/ctf/iterator.rb
+- lib/babeltrace/format.rb
+- lib/babeltrace/iterator.rb
+- lib/babeltrace/list.rb
+- lib/babeltrace/trace_handle.rb
+- lib/babeltrace/types.rb
+homepage: https://github.com/alcf-perfengr/babeltrace-ruby
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.6.2
+signing_key: 
+specification_version: 4
+summary: Ruby libbabeltrace bindings
+test_files: []