metababel 0.0.0

data/lib/metababel/bt2_values_generator.rb

@@ -0,0 +1,132 @@
+require_relative 'bt2_generator_utils'
+
+module Babeltrace2Gen
+  class BTValueCLass
+    attr_accessor :cast_type
+
+    def self.from_h(model)
+      key = model.delete(:type)
+      raise "No type in #{model}" unless key
+
+      h = { 'map' => BTValueCLass::Map,
+            'string' => BTValueCLass::String,
+            'bool' => BTValueCLass::Bool,
+            'integer_unsigned' => BTValueCLass::IntegerUnsigned }.freeze
+      raise "Type #{key} not supported" unless h.include?(key)
+
+      cast_type = model.delete(:cast_type)
+      fc = h[key].from_h(model)
+      fc.cast_type = cast_type if cast_type
+      fc
+    end
+  end
+
+  class BTValueCLass::Scalar < BTValueCLass
+    attr_accessor :name, :usr_default_value
+
+    include BTPrinter
+
+    # Scalars are leafs, avoid recursion
+    def self.from_h(model)
+      new(model[:name],model.fetch(:default_value,nil))
+    end
+
+    def initialize(name,usr_default_value)
+      @name = name
+      @usr_default_value = usr_default_value
+    end
+
+    def get(name, val)
+      cast_func = @cast_type ? "(#{@cast_type})" : ''
+      bt_default_value = self.class.instance_variable_get(:@bt_default_value)
+      bt_type = self.class.instance_variable_get(:@bt_type)
+      bt_type_is = self.class.instance_variable_get(:@bt_type_is)
+
+      default_value = @usr_default_value || bt_default_value
+
+      pr "if (#{val} != NULL) {"
+      pr "  if (!#{bt_type_is}(#{val})) {"
+      pr "    fprintf(stderr,\"Bad value for command line argument '%s' the value must be '%s'. \\n\",\"#{@name}\",\"#{bt_type}\");"
+      pr "    exit(1);"
+      pr "  }"
+      pr "  #{name} = #{cast_func}bt_value_#{bt_type}_get(#{val});"
+      pr "} else {"
+      pr "  #{name} = #{cast_func}#{default_value};"
+      pr "}"
+    end
+  end
+
+  class BTValueCLass::Map < BTValueCLass
+    include BTPrinter
+
+    def self.from_h(model)
+      new(model[:entries])
+    end
+
+    def initialize(entries = [])
+      @entries = entries.collect { |m| BTValueCLass.from_h(**m) }
+    end
+
+    def get(struct, map)
+      @entries.map do |m|
+        scope do
+          pr "const bt_value *val = bt_value_map_borrow_entry_value_const(#{map}, \"#{m.name}\");"
+          m.get("#{struct}->#{m.name}", 'val')
+        end
+      end
+    end
+
+    def get_struct_definition(_name)
+      @entries.map do |e|
+        type = e.cast_type || e.class.instance_variable_get(:@bt_return_type)
+        "  #{type} #{e.name};"
+      end.join("\n")
+    end
+  end
+
+  class BTValueCLass::Bool < BTValueCLass::Scalar
+    @bt_type = 'bool'
+    @bt_type_is = 'bt_value_is_bool'
+    @bt_return_type = 'bt_bool'
+    @bt_default_value = 'BT_FALSE'
+
+    def initialize(name,usr_default_value)
+      bt_type = self.class.instance_variable_get(:@bt_type)
+      if !usr_default_value.nil? and !['BT_TRUE', 'BT_FALSE'].include? usr_default_value
+        raise "Bad default_value for '#{name}' in params.yaml, it must be #{bt_type} (BT_TRUE or BT_FALSE) but provided '#{usr_default_value}'."
+      end
+      super(name,usr_default_value)
+    end
+  end
+
+  class BTValueCLass::String < BTValueCLass::Scalar
+    @bt_type = 'string'
+    @bt_type_is = 'bt_value_is_string'
+    @bt_return_type = 'const char*'
+    @bt_default_value = 'NULL'
+
+    def initialize(name,usr_default_value)
+      bt_type = self.class.instance_variable_get(:@bt_type)
+      # Every object that can be converted to string is being supported.
+      if !usr_default_value.nil? and !usr_default_value.respond_to?(:to_s)
+          raise "Bad default_value for '#{name}' in params.yaml, it must be #{bt_type} but provided '#{usr_default_value}'." 
+      end
+      super(name,usr_default_value.to_s.inspect)
+    end
+  end
+
+  class BTValueCLass::IntegerUnsigned < BTValueCLass::Scalar
+    @bt_type = 'integer_unsigned'
+    @bt_type_is = 'bt_value_is_signed_integer'
+    @bt_return_type = 'uint64_t'
+    @bt_default_value = '0'
+
+    def initialize(name,usr_default_value)
+      bt_type = self.class.instance_variable_get(:@bt_type)
+      if !usr_default_value.nil? and (!usr_default_value.kind_of? Integer or !usr_default_value.between?(0,2**64-1))
+          raise "Bad default_value for '#{name}' in params.yaml, it must be #{bt_type} and must be in [0,2^64-1], but provided '#{usr_default_value}'." 
+      end
+      super(name,usr_default_value)
+    end
+  end
+end

data/lib/metababel/version.rb

@@ -0,0 +1,3 @@
+module Metababel
+  VERSION = '0.0.0'
+end

data/lib/metababel.rb

@@ -0,0 +1,4 @@
+require 'metababel/bt2_generator_utils'
+require 'metababel/bt2_stream_classes_generator'
+require 'metababel/bt2_values_generator'
+require 'metababel/version'

data/template/component.c.erb

@@ -0,0 +1,69 @@
+#include "utarray.h"
+#include "uthash.h"
+#include <assert.h>
+#include <babeltrace2/babeltrace.h>
+#include <metababel/btx_component.h>
+#include <stdbool.h>
+// stdio needed because `params_definition` contain fprintf
+#include <stdio.h>
+
+void btx_populate_params(common_data_t *common_data) {
+  const bt_value *params = common_data->params;
+  btx_params_t *usr_params = common_data->btx_params;
+  (void)params;
+  (void)usr_params;
+  <%= params_definition %>
+}
+
+<% component_dispatchers.each do |e| %>
+
+typedef void btx_dispatch_<%= e.name_sanitized %>_f(
+    UT_array *callbacks, common_data_t *common_data,
+    <%= e.args.map{ |s| s.type }.join(", ") %>);
+
+static void btx_dispatch_<%= e.name_sanitized %>(
+    UT_array *callbacks, common_data_t *common_data,
+    <%= e.args.map{ |s| "#{s.type} #{s.name}" }.join(", ") %>) {
+
+  // Call all the callbacks who where registered
+  // Their type are declared in 'upstream.h'
+  <%= e.name_sanitized %>_callback_f **p = NULL;
+  while ((p = utarray_next(callbacks, p))) {
+    (*p)((void *)common_data, <%= e.args.map{ |s| s.name }.join(", ") %>);
+  }
+}
+
+void btx_register_callbacks_<%= e.name_sanitized %>(
+    void *btx_handle, <%= e.name_sanitized %>_callback_f *callback) {
+  // Look-up our dispatcher
+  name_to_dispatcher_t *s = NULL;
+  name_to_dispatcher_t **name_to_dispatcher =
+      &((common_data_t *)btx_handle)->name_to_dispatcher;
+  HASH_FIND_STR(*name_to_dispatcher, "<%= e.name %>", s);
+  if (!s) {
+    // We didn't find the dispatcher, so we need to:
+    // 1. Create it
+    s = (name_to_dispatcher_t *)malloc(sizeof(name_to_dispatcher_t));
+    s->name = "<%= e.name %>";
+    s->dispatcher = (void *)&btx_dispatch_<%= e.name_sanitized %>;
+    utarray_new(s->callbacks, &ut_ptr_icd);
+    // 2. Register it
+    HASH_ADD_KEYPTR(hh, *name_to_dispatcher, s->name, strlen(s->name), s);
+    // 3. Add the callbacks to the array
+    utarray_push_back(s->callbacks, &callback);
+  } else {
+    assert(false && "Only one callbacks for <%= e.name_sanitized %>");
+  }
+}
+
+void btx_call_callbacks_<%= e.name_sanitized %>(
+    common_data_t *common_data,
+    <%= e.args.map{ |s| "#{s.type} #{s.name}" }.join(", ") %>) {
+  name_to_dispatcher_t *s = NULL;
+  HASH_FIND_STR(common_data->name_to_dispatcher, "<%= e.name %>", s);
+
+  if (s)
+    (*((btx_dispatch_<%= e.name_sanitized %>_f(*))(s->dispatcher)))(
+        s->callbacks, common_data, <%= e.args.map{ |s| s.name }.join(", ") %>);
+}
+<% end %>

data/template/component.h.erb

@@ -0,0 +1,160 @@
+#pragma once
+
+#include "utarray.h"
+#include "uthash.h"
+#include <babeltrace2/babeltrace.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// Forward declaration of common_data
+struct common_data_s;
+typedef struct common_data_s common_data_t;
+
+// Params
+struct btx_params_s {
+  <%= params_declaration %>
+
+}; <%# Need empty line for nice code gen %>
+typedef struct btx_params_s btx_params_t;
+
+void btx_populate_params(common_data_t *common_data_t);
+
+<% if options.key?(:usr_data_header) %>
+#include "<%= options[:usr_data_header] %>"
+<% end %>
+
+struct name_to_dispatcher_s {
+  const char *name;
+  void *dispatcher;
+  UT_array *callbacks;
+  UT_hash_handle hh;
+};
+typedef struct name_to_dispatcher_s name_to_dispatcher_t;
+
+<% if ['SOURCE', 'FILTER'].include?(options[:component_type]) %>
+// Structure for Downstream Message
+struct el {
+  const bt_message *message;
+  struct el *next, *prev;
+};
+
+<% end %>
+// Struct stored in the component via `bt_self_component_set_data`
+<% if options[:component_type] == 'SOURCE' %>
+struct common_data_s {
+  name_to_dispatcher_t *name_to_dispatcher;
+  void *usr_data;
+  const bt_value *params;
+  btx_params_t *btx_params;
+  bt_trace *downstream_trace;
+  /* Used by downstream.c */
+  bt_self_message_iterator *self_message_iterator;
+};
+
+enum btx_source_state_e {
+  BTX_SOURCE_STATE_INITIALIZING,
+  BTX_SOURCE_STATE_PROCESSING,
+  BTX_SOURCE_STATE_FINALIZING,
+  BTX_SOURCE_STATE_FINISHED,
+  BTX_SOURCE_STATE_ERROR,
+};
+typedef enum btx_source_state_e btx_source_state_t;
+
+/* Message iterator's private data */
+struct btx_message_iterator_s {
+  /* (Weak) link to the component's private data */
+  common_data_t *common_data;
+  btx_source_state_t state;
+
+  /* Handling the downstream message queue */
+  struct el *queue;
+  struct el *pool;
+};
+typedef struct btx_message_iterator_s btx_message_iterator_t;
+
+enum btx_source_status_e {
+  BTX_SOURCE_END,
+  BTX_SOURCE_OK,
+};
+typedef enum btx_source_status_e btx_source_status_t;
+
+<% elsif options[:component_type] == 'FILTER' %>
+struct common_data_s {
+  name_to_dispatcher_t *name_to_dispatcher;
+  void *usr_data;
+  const bt_value *params;
+  btx_params_t *btx_params;
+  /* Component's input port (weak) */
+  const bt_component_filter *component;
+  bt_trace *downstream_trace;
+  /* Used by downstream.c */
+  bt_self_message_iterator *self_message_iterator;
+};
+
+enum btx_filter_state_e {
+  BTX_FILTER_STATE_INITIALIZING,
+  BTX_FILTER_STATE_PROCESSING,
+  BTX_FILTER_STATE_FINALIZING,
+  BTX_FILTER_STATE_FINISHED,
+  BTX_FILTER_STATE_ERROR,
+};
+typedef enum btx_filter_state_e btx_filter_state_t;
+
+enum btx_filter_processing_state_e {
+  BTX_FILTER_PROCESSING_STATE_READING,
+  BTX_FILTER_PROCESSING_STATE_SENDING,
+  BTX_FILTER_PROCESSING_STATE_FINISHED,
+};
+typedef enum btx_filter_processing_state_e btx_filter_processing_state_t;
+
+typedef struct el_mi {
+  /* Upstream message iterator (owned by this) */
+  bt_message_iterator *message_iterator;
+  struct el_mi *next, *prev;
+} el_mi;
+
+/* Message iterator's private data */
+struct btx_message_iterator_s {
+  /* (Weak) link to the component's private data */
+  common_data_t *common_data;
+  /*  Upstream messages iterator */
+  el_mi *head_mi;
+  btx_filter_state_t state;
+  btx_filter_processing_state_t processing_state;
+  /* Handling the downstream message queue */
+  struct el *queue;
+  struct el *pool;
+};
+typedef struct btx_message_iterator_s btx_message_iterator_t;
+
+<% elsif options[:component_type] == 'SINK' %>
+struct common_data_s {
+  name_to_dispatcher_t *name_to_dispatcher;
+  void *usr_data;
+  const bt_value *params;
+  btx_params_t *btx_params;
+  /* Upstream message iterator (owned by this) */
+  bt_message_iterator *message_iterator;
+};
+<% end %>
+
+void btx_register_usr_callbacks(void *btx_handle);
+
+<% component_dispatchers.each do |e| %>
+<%# The signature type of callbacks %>
+typedef void
+<%= e.name_sanitized %>_callback_f(void *btx_handle,
+                                   <%= e.args.map{ |s| s.type }.join(", ") %>);
+<%# The Function who register the callbacks to the dispatcher %>
+void btx_register_callbacks_<%= e.name_sanitized %>(
+    void *btx_handle, <%= e.name_sanitized %>_callback_f *callback);
+
+void btx_call_callbacks_<%= e.name_sanitized %>(
+    common_data_t *common_data, <%= e.args.map{ |s| s.type }.join(", ") %>);
+<% end %>
+
+#ifdef __cplusplus
+}
+#endif

data/template/downstream.c.erb

@@ -0,0 +1,119 @@
+#include "utlist.h"
+#include <babeltrace2/babeltrace.h>
+#include <metababel/btx_component.h>
+#include <metababel/btx_downstream.h>
+#include <stdlib.h>
+
+void btx_downstream_move_messages(
+    btx_message_iterator_t *message_iterator_private_data,
+    bt_message_array_const messages, uint64_t capacity, uint64_t *count) {
+
+  // Set count to min(capacity, common_data->queue.size())
+  // Count time, pop the head of the queue and put it in messages
+  for (*count = 0; *count < capacity && message_iterator_private_data->queue;
+       (*count)++) {
+    struct el *elt = message_iterator_private_data->queue;
+    messages[*count] = elt->message;
+    DL_DELETE(message_iterator_private_data->queue, elt);
+    // Put it back to the bool of chain for reuse
+    DL_APPEND(message_iterator_private_data->pool, elt);
+  }
+}
+
+void btx_downstream_push_message(
+    btx_message_iterator_t *message_iterator_private_data,
+    const bt_message *message) {
+
+  struct el *elt;
+  if (message_iterator_private_data->pool) {
+    elt = message_iterator_private_data->pool;
+    DL_DELETE(message_iterator_private_data->pool, elt);
+  } else {
+    elt = (struct el *)malloc(sizeof *elt);
+  }
+  elt->message = message;
+  DL_APPEND(message_iterator_private_data->queue, elt);
+}
+
+bt_trace_class *
+btx_downstream_trace_class_create_rec(bt_self_component *self_component) {
+  bt_trace_class *trace_class = bt_trace_class_create(self_component);
+  <%= body_declarator_classes %>
+  return trace_class;
+}
+
+bt_trace *btx_downstream_trace_create_rec(bt_trace_class *trace_class) {
+  bt_trace *trace = bt_trace_create(trace_class);
+  <% stream_classes.each_with_index do |_,i| %>
+  {
+    bt_stream_class *stream_class =
+        bt_trace_class_borrow_stream_class_by_index(trace_class, <%= i %>);
+    bt_stream_create(stream_class, trace);
+  }
+  <% end %>
+  return trace;
+}
+
+void btx_push_messages_stream_beginning(
+    bt_self_message_iterator *self_message_iterator,
+    btx_message_iterator_t *message_iterator_private_data) {
+
+  bt_trace *trace =
+      message_iterator_private_data->common_data->downstream_trace;
+  <% stream_classes.each_with_index do |_,i| %>
+  {
+    bt_stream *stream = bt_trace_borrow_stream_by_index(trace, <%= i %>);
+    bt_message *message =
+        bt_message_stream_beginning_create(self_message_iterator, stream);
+    btx_downstream_push_message(message_iterator_private_data, message);
+  }
+  <% end %>
+}
+
+void btx_push_messages_stream_end(
+    bt_self_message_iterator *self_message_iterator,
+    btx_message_iterator_t *message_iterator_private_data) {
+
+  bt_trace *trace =
+      message_iterator_private_data->common_data->downstream_trace;
+  <% stream_classes.each_with_index do |_,i| %>
+  {
+    bt_stream *stream = bt_trace_borrow_stream_by_index(trace, <%= i %>);
+    bt_message *message =
+        bt_message_stream_end_create(self_message_iterator, stream);
+    btx_downstream_push_message(message_iterator_private_data, message);
+  }
+  <% end %>
+}
+
+<% downstream_events.each do |e| %>
+static void btx_set_message_<%= e.name_sanitized %>(
+    bt_event *<%= event_name %>,
+    <%= e.args.map{ |s| "#{s.type} #{s.name}" }.join(", ") %>) {
+  <%= e.body %>
+}
+
+void btx_push_message_<%= e.name_sanitized %>(
+    void *btx_handle,
+    <%= e.args.map{ |s| "#{s.type} #{s.name}" }.join(", ") %>) {
+
+  common_data_t *common_data = (common_data_t *)btx_handle;
+
+  bt_stream *stream = bt_trace_borrow_stream_by_index(
+      common_data->downstream_trace, <%= e.index_stream_class %>);
+  bt_stream_class *stream_class = bt_stream_borrow_class(stream);
+  bt_event_class *event_class = bt_stream_class_borrow_event_class_by_index(
+      stream_class, <%= e.index_event_class %>);
+
+  bt_message *message = bt_message_event_create(
+      common_data->self_message_iterator, event_class, stream);
+  bt_event *downstream_event = bt_message_event_borrow_event(message);
+
+  btx_set_message_<%= e.name_sanitized %>(
+      downstream_event, <%= e.args.map{ |s| s.name }.join(", ") %>);
+
+  btx_message_iterator_t *message_iterator_private_data =
+      bt_self_message_iterator_get_data(common_data->self_message_iterator);
+  btx_downstream_push_message(message_iterator_private_data, message);
+}
+<% end %>

data/template/downstream.h.erb

@@ -0,0 +1,34 @@
+#pragma once
+#include <babeltrace2/babeltrace.h>
+#include <metababel/btx_component.h>
+#ifdef __cplusplus
+extern "C" {
+#endif
+void btx_downstream_move_messages(
+    btx_message_iterator_t *message_iterator_private_data,
+    bt_message_array_const messages, uint64_t capacity, uint64_t *count);
+
+void btx_downstream_push_message(
+    btx_message_iterator_t *message_iterator_private_data,
+    const bt_message *message);
+
+bt_trace_class *
+btx_downstream_trace_class_create_rec(bt_self_component *self_component);
+
+bt_trace *btx_downstream_trace_create_rec(bt_trace_class *trace_class);
+
+void btx_push_messages_stream_beginning(
+    bt_self_message_iterator *self_message_iterator,
+    btx_message_iterator_t *message_iterator_private_data);
+void btx_push_messages_stream_end(
+    bt_self_message_iterator *self_message_iterator,
+    btx_message_iterator_t *message_iterator_private_data);
+
+<% downstream_events.each do |e| %>
+void btx_push_message_<%= e.name_sanitized %>(
+    void *btx_handle,
+    <%= e.args.map{ |s| "#{s.type} #{s.name}" }.join(", ") %>);
+<% end %>
+#ifdef __cplusplus
+}
+#endif