metababel 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 579d0e3d53d8a2cc77b458621e278d01e98cc5a9b736f9615671c35d5a7ec881
+  data.tar.gz: dede291f1c00394ed257784551fc3c2cffbcd1c9d5404fdb305f272d10c4bb41
+SHA512:
+  metadata.gz: 8da116eba6fc46b84324f10ace6a46aad4b8144d8ec4eadbbfe80c380abf4cd2cd7deaafcc70e3ac86ce3e6ce4971e354029ff93b7885f87e19cb455a6d22a37
+  data.tar.gz: 585f64b8cb02ab0255d131a94f4ecda9fa24dcd7ecaecc7d1ffa9825004671dd550054fbdd638ac3a0fe597fbf1881f1b78cc6ab4cea2c00e75a9b009f6b55ea

data/README.md

@@ -0,0 +1,60 @@
+<img width="384" alt="METABABEL" src="https://user-images.githubusercontent.com/6524907/217338770-ab69a6c8-f0fa-4e00-9b8f-bf5d2192d0bd.png">
+
+# What symbols to provide?
+
+## Filter & Sink
+
+Link with a object file who export the symbol `btx_register_usr_callbacks(void *)`.
+
+The implementation of `btx_register_usr_callbacks` should conssist of calls to `btx_register_callbacks_#{stream_class_name}_#{event_class_name}(btx_handle, &callbacks)`.
+
+## Source:
+
+Link with a object file who export the symbol `btx_push_usr_messages(struct xprof_common_data *common_data)`.
+
+# Function Provided
+
+## Source & Filter
+	
+In the callbacks, and in the `btx_push_usr_messages`, you have access to `btx_push_message_{stream_class_name}_#{event_class_name}(struct xprof_common_data *common_data, ...)`.
+
+
+# Source Description
+
+## State Machine
+
+```mermaid
+stateDiagram-v2
+    [*] --> BTX_SOURCE_STATE_INITIALIZING
+    BTX_SOURCE_STATE_INITIALIZING --> BTX_SOURCE_STATE_PROCESSING
+    BTX_SOURCE_STATE_PROCESSING --> BTX_SOURCE_STATE_FINALIZING
+    BTX_SOURCE_STATE_FINALIZING --> BTX_FILTER_STATE_FINISHED
+    BTX_FILTER_STATE_FINISHED --> [*]
+```
+
+# Filter Description
+
+## State Machine
+
+```mermaid
+stateDiagram-v2
+    [*] --> BTX_SOURCE_STATE_INITIALIZING
+    BTX_SOURCE_STATE_INITIALIZING --> BTX_FILTER_PROCESSING
+    state BTX_FILTER_PROCESSING {
+        [*] --> BTX_FILTER_PROCESSING_STATE_READING
+        [*] --> BTX_FILTER_PROCESSING_STATE_SENDING
+	BTX_FILTER_PROCESSING_STATE_SENDING --> BTX_FILTER_PROCESSING_STATE_READING
+    	BTX_FILTER_PROCESSING_STATE_READING --> BTX_FILTER_PROCESSING_STATE_SENDING
+	BTX_FILTER_PROCESSING_STATE_READING --> BTX_FILTER_PROCESSING_STATE_FINISHED
+	BTX_FILTER_PROCESSING_STATE_FINISHED --> [*]
+    }
+    BTX_FILTER_PROCESSING --> BTX_FILTER_STATE_FINALIZING
+    BTX_FILTER_STATE_FINALIZING --> BTX_FILTER_STATE_FINISHED
+    BTX_FILTER_STATE_FINISHED --> [*]
+```
+
+# Sink Description
+
+At finalization we will call the `btx_user_finalization(struct xprof_common_data *common_data)`
+
+

data/bin/metababel

@@ -0,0 +1,233 @@
+#!/usr/bin/env ruby
+
+require 'yaml'
+require 'optparse'
+require 'erb'
+require 'metababel'
+require 'fileutils'
+
+def validate_model(yaml)
+  raise "Invalid Model #{yaml}" unless yaml[:stream_classes].all? do |d|
+                                         d.key?(:event_common_context_field_class) || d[:event_classes].all? do |d2|
+                                           d2.key?(:payload_field_class)
+                                         end
+                                       end
+end
+
+class Hash
+  # Copy pasted from rails (https://apidock.com/rails/Hash/deep_merge%21)
+  def deep_merge!(other_hash, &block)
+    merge!(other_hash) do |key, this_val, other_val|
+      if this_val.is_a?(Hash) && other_val.is_a?(Hash)
+        this_val.deep_merge(other_val, &block)
+      elsif block_given?
+        block.call(key, this_val, other_val)
+      else
+        other_val
+      end
+    end
+  end
+
+  def deep_merge(other_hash, &block)
+    dup.deep_merge!(other_hash, &block)
+  end
+end
+
+EventInfo = Struct.new(:name, :args, :body, :index_stream_class, :index_event_class) do
+  def name_sanitized
+    name.gsub(/[^0-9A-Za-z-]/, '_')
+  end
+end
+
+def erb_render_and_save(vars,
+                        basename, out_folder, out_name: nil, prefix: 'btx_')
+  template = File.read(File.join(__dir__, "../template/#{basename}.erb"))
+  # We need to trim line who contain only with space, because we indent our erb block <% %>
+  # The trim_mode remove line only when it's start with the erb block
+  # The regex remove the lines who are not indented
+  # Maybe related to `https://github.com/ruby/erb/issues/24`
+  str = ERB.new(template, trim_mode: '<>').result_with_hash(vars).gsub(/^ +$\n/, '')
+  File.open(File.join(out_folder, "#{prefix}#{out_name || basename}"), 'w') do |f|
+    f.write(str)
+  end
+end
+
+class Babeltrace2Gen::BTTraceClass
+  def map_event_classes_with_index
+    @stream_classes.map.with_index do |s, index_stream_class|
+      s.event_classes.map.with_index do |e, index_event_class|
+        yield(e, index_stream_class, index_event_class)
+      end
+    end.flatten
+  end
+end
+
+class GeneratedArg < Struct.new(:type, :name)
+end
+
+# We preprent an empty new line from the body as a hack, to correct the indentation
+# Indeeed the <%= body %> will be indented, but we don't don't want it,
+# in the body string is already indented
+# But we clean the white space empty line afterward \o/
+def wrote_event_dispatchers(folder, t)
+  event_name = 'event'
+  event_dispatchers = t.map_event_classes_with_index do |e, index_stream_class, index_event_class|
+    arg_variables = []
+    body = Babeltrace2Gen.context(indent: 1) do
+      e.get_getter(event: event_name, arg_variables: arg_variables)
+    end
+    EventInfo.new(e.name, arg_variables, "\n" + body, index_stream_class, index_event_class)
+  end
+
+  d = { event_dispatchers: event_dispatchers,
+        event_name: event_name }
+
+  erb_render_and_save(d, 'upstream.h', folder)
+  erb_render_and_save(d, 'upstream.c', folder)
+end
+
+def wrote_creates(folder, t)
+  event_name = 'event'
+  downstream_events = t.map_event_classes_with_index do |e, index_stream_class, index_event_class|
+    arg_variables = []
+    body = Babeltrace2Gen.context(indent: 1) do
+      e.get_setter(event: event_name, arg_variables: arg_variables)
+    end
+    EventInfo.new(e.name, arg_variables, "\n" + body, index_stream_class, index_event_class)
+  end
+
+  body_declarator_classes = "\n" + Babeltrace2Gen.context(indent: 1) do
+    t.get_declarator(variable: 'trace_class')
+  end
+
+  d = { body_declarator_classes: body_declarator_classes,
+        downstream_events: downstream_events,
+        stream_classes: t.stream_classes,
+        event_name: event_name }
+
+  erb_render_and_save(d, 'downstream.h', folder)
+  erb_render_and_save(d, 'downstream.c', folder)
+end
+
+def wrote_component(options, d, folder)
+
+  component_dispatchers = [EventInfo.new('initialize_usr_data',
+                                         [GeneratedArg.new('void **', 'usr_data_p')]),
+                           EventInfo.new('finalize_usr_data',
+                                         [GeneratedArg.new('void *', 'usr_data')]),
+                           EventInfo.new('read_params',
+                                         [GeneratedArg.new('void *', 'usr_data'),
+                                          GeneratedArg.new('btx_params_t *', 'usr_params')])
+                          ]
+
+  if options[:component_type] == "SOURCE"
+     component_dispatchers <<  EventInfo.new('push_usr_messages',
+                                         [GeneratedArg.new('void *', 'usr_data'),
+                                          GeneratedArg.new('btx_source_status_t*', 'status') ])
+  end
+
+  d2 = { component_dispatchers: component_dispatchers,
+         event_name: 'dummy_event' }
+
+  erb_render_and_save(d2.update(d).update(:options => options), 'component.h', folder)
+  erb_render_and_save(d2.update(d).update(:options => options), 'component.c', folder)
+end
+
+options = { plugin_name: 'metababel',
+            component_name: 'btx' }
+
+# Display help if no arguments.
+ARGV << '-h' if ARGV.empty?
+
+OptionParser.new do |opts|
+  opts.banner = 'Usage: example.rb [options]'
+
+  opts.on('-h', '--help', 'Prints this help') do
+    puts opts
+    exit
+  end
+
+  opts.on('-v', '--version', 'Prints this help') do
+    puts "Ruby: #{RUBY_VERSION}"
+    puts "Metababel: #{Metababel::VERSION}"
+    exit
+  end
+
+  opts.on('-t', '--component TYPE', '[Mandatory] Node within a trace processing graph.') do |p|
+    options[:component_type] = p
+  end
+
+  opts.on('-u', '--upstreams PATH', Array, '[Mandatory] Path to the bt2 yaml file.') do |p|
+    options[:upstreams] = p
+  end
+
+  opts.on('-d', '--downstream PATH', '[Optional] Path to the bt2 yaml file.') do |p|
+    options[:downstream] = p
+  end
+
+  opts.on('-p', '--plugin-name PATH', '[Optional] Name of the bt2 plugin created.') do |p|
+    options[:plugin_name] = p
+  end
+
+  opts.on('-c', '--component-name PATH', '[Optional] Name of the bt2 componant created.') do |p|
+    options[:component_name] = p
+  end
+
+  opts.on('--params PATH', '[Optional] Name of YAML params definition.') do |p|
+    options[:params] = p
+  end
+
+  opts.on('-o', '--output FOLDER', '[Optional] Output folder path.') do |p|
+    options[:folder] = p
+  end
+
+  opts.on('-i', '--usr-data-header NAME', '[Optional] User datatypes definitions.') do |p|
+    options[:usr_data_header] = p
+  end
+end.parse!
+
+raise OptionParser::MissingArgument if options[:component_type].nil?
+
+# Babeltrace can be extended by plugins, which provide one or more component classes.
+base_folder = options[:folder] || "#{options[:component_type]}.#{options[:plugin_name]}.#{options[:component_name]}"
+folder = "#{base_folder}/metababel"
+FileUtils.mkdir_p(folder)
+
+d = {:options => options}
+
+d[:params_declaration] = ''
+d[:params_definition] = ''
+if options.key?(:params)
+  y = YAML.load_file(options[:params])
+  c = Babeltrace2Gen::BTValueCLass.from_h(y)
+  body = Babeltrace2Gen.context(indent: 1) do
+    c.get('usr_params', 'params')
+  end
+  d[:params_declaration] = c.get_struct_definition('params')
+  d[:params_definition] = body
+end
+
+erb_render_and_save(d, "#{options[:component_type].downcase}.c", base_folder, out_name: "#{options[:plugin_name]}.c")
+erb_render_and_save({options: options}, 'metababel.h', folder, prefix: '')
+
+wrote_component(options, d, folder)
+if %w[SOURCE FILTER].include?(options[:component_type])
+  raise 'Missing downstream model' unless options[:downstream]
+
+  y = YAML.load_file(options[:downstream])
+  validate_model(y)
+  t = Babeltrace2Gen::BTTraceClass.from_h(nil, y)
+  wrote_creates(folder, t)
+end
+
+if %w[FILTER SINK].include?(options[:component_type])
+  raise 'Missing upstream models' unless options[:upstreams]
+
+  y = options[:upstreams].reduce({}) do |y, upstream|
+    # Need to specialize for merging arrays
+    y.deep_merge(YAML.load_file(upstream)) { |_key, old, new| old + new }
+  end
+  validate_model(y)
+  t = Babeltrace2Gen::BTTraceClass.from_h(nil, y)
+  wrote_event_dispatchers(folder, t)
+end

data/lib/metababel/bt2_generator_utils.rb

@@ -0,0 +1,38 @@
+module Babeltrace2Gen
+  module BTPrinter
+    @@output = ''
+    @@indent = 0
+    INDENT_INCREMENT = '  '.freeze
+
+    def pr(str)
+      @@output << INDENT_INCREMENT * @@indent << str << "\n"
+    end
+    module_function :pr
+
+    def scope
+      pr '{'
+      @@indent += 1
+      yield
+      @@indent -= 1
+      pr '}'
+    end
+
+    def self.context(output: '', indent: 0)
+      @@output = output
+      @@indent = indent
+      yield
+      @@output
+    end
+
+    # Maybe not the best place
+    def name_sanitized
+      raise unless @name
+
+      @name.gsub(/[^0-9A-Za-z\-]/, '_')
+    end
+  end
+
+  def self.context(**args, &block)
+    BTPrinter.context(**args, &block)
+  end
+end