metababel 0.0.0

data/template/source.c.erb

@@ -0,0 +1,200 @@
+#include "uthash.h"
+#include "utlist.h"
+#include <babeltrace2/babeltrace.h>
+#include <metababel/metababel.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+/* Loosely inspired by
+ * https://babeltrace.org/docs/v2.0/libbabeltrace2/example-simple-src-cmp-cls.html
+ */
+
+/*
+ *  Handle Upstream Messages
+ */
+static bt_message_iterator_class_next_method_status
+source_message_iterator_next(bt_self_message_iterator *self_message_iterator,
+                             bt_message_array_const messages, uint64_t capacity,
+                             uint64_t *count) {
+
+  /* The clean thing to do will be to refractor the code, so we can reuse some
+   * part of the filter state-machine... For now unoptimal and simple state
+   * machine will be enough */
+
+  /* Retrieve our private data from the message iterator's user data */
+  btx_message_iterator_t *message_iterator_private_data =
+      bt_self_message_iterator_get_data(self_message_iterator);
+
+  /* When you return BT_MESSAGE_ITERATOR_CLASS_NEXT_METHOD_STATUS_END, you must
+   * not put any message into the message array */
+  switch (message_iterator_private_data->state) {
+  case BTX_SOURCE_STATE_INITIALIZING:
+    /* Begining of Stream */
+    btx_push_messages_stream_beginning(self_message_iterator,
+                                       message_iterator_private_data);
+
+    /* Call Initialize user callback */
+    btx_call_callbacks_initialize_usr_data(
+        message_iterator_private_data->common_data,
+        &message_iterator_private_data->common_data->usr_data);
+    /* Call read callbacks */
+    btx_call_callbacks_read_params(
+        message_iterator_private_data->common_data,
+        message_iterator_private_data->common_data->usr_data,
+        message_iterator_private_data->common_data->btx_params);
+
+    message_iterator_private_data->state = BTX_SOURCE_STATE_PROCESSING;
+    return BT_MESSAGE_ITERATOR_CLASS_NEXT_METHOD_STATUS_AGAIN;
+  case BTX_SOURCE_STATE_PROCESSING:
+    if (message_iterator_private_data->queue) {
+      btx_downstream_move_messages(message_iterator_private_data, messages,
+                                   capacity, count);
+      return BT_MESSAGE_ITERATOR_CLASS_NEXT_METHOD_STATUS_OK;
+    }
+
+    btx_source_status_t status = BTX_SOURCE_END;
+
+    btx_call_callbacks_push_usr_messages(
+        message_iterator_private_data->common_data,
+        message_iterator_private_data->common_data->usr_data, &status);
+    if (status == BTX_SOURCE_END) {
+
+      /* Call Finalize user callback */
+      btx_call_callbacks_finalize_usr_data(
+          message_iterator_private_data->common_data,
+          message_iterator_private_data->common_data->usr_data);
+      /* End of Stream */
+      btx_push_messages_stream_end(self_message_iterator,
+                                   message_iterator_private_data);
+      message_iterator_private_data->state = BTX_SOURCE_STATE_FINALIZING;
+    }
+    return BT_MESSAGE_ITERATOR_CLASS_NEXT_METHOD_STATUS_AGAIN;
+  case BTX_SOURCE_STATE_FINALIZING:
+    if (message_iterator_private_data->queue) {
+      btx_downstream_move_messages(message_iterator_private_data, messages,
+                                   capacity, count);
+      return BT_MESSAGE_ITERATOR_CLASS_NEXT_METHOD_STATUS_OK;
+    }
+    message_iterator_private_data->state = BTX_SOURCE_STATE_FINISHED;
+    return BT_MESSAGE_ITERATOR_CLASS_NEXT_METHOD_STATUS_END;
+  case BTX_SOURCE_STATE_FINISHED:
+    return BT_MESSAGE_ITERATOR_CLASS_NEXT_METHOD_STATUS_END;
+  default:
+    return BT_MESSAGE_ITERATOR_CLASS_NEXT_METHOD_STATUS_ERROR;
+  }
+}
+
+/*
+ * Initializes the source component.
+ */
+bt_component_class_initialize_method_status
+source_initialize(bt_self_component_source *self_component_source,
+                  bt_self_component_source_configuration *configuration,
+                  const bt_value *params, void *initialize_method_data) {
+  /* Allocate a private data structure */
+  common_data_t *common_data = calloc(1, sizeof(common_data_t));
+  common_data->params = params;
+  // Read parameters
+  btx_populate_params(common_data);
+  bt_value_get_ref(common_data->params);
+
+  /* Register User Callbacks */
+  btx_register_usr_callbacks((void *)common_data);
+  /* Upcast `self_component_source` to the `bt_self_component` type */
+  bt_self_component *self_component =
+      bt_self_component_source_as_self_component(self_component_source);
+
+  bt_trace_class *trace_class =
+      btx_downstream_trace_class_create_rec(self_component);
+
+  /* Instantiate a `downstream_trace` of `trace_class` and all the children
+   * stream */
+  common_data->downstream_trace = btx_downstream_trace_create_rec(trace_class);
+
+  /* Set the component's user data to our private data structure */
+  bt_self_component_set_data(self_component, common_data);
+
+  /*
+   * Add an output port named `out` to the source component.
+   *
+   * This is needed so that this source component can be connected to
+   * a filter or a sink component. Once a downstream component is
+   * connected, it can create our message iterator.
+   */
+  bt_self_component_source_add_output_port(self_component_source, "out", NULL,
+                                           NULL);
+
+  return BT_COMPONENT_CLASS_INITIALIZE_METHOD_STATUS_OK;
+}
+
+/*
+ * Initializes the message iterator.
+ */
+static bt_message_iterator_class_initialize_method_status
+source_message_iterator_initialize(
+    bt_self_message_iterator *self_message_iterator,
+    bt_self_message_iterator_configuration *configuration,
+    bt_self_component_port_output *self_port) {
+  /* Allocate a private data structure */
+  btx_message_iterator_t *message_iterator_private_data =
+      calloc(1, sizeof(btx_message_iterator_t));
+
+  message_iterator_private_data->state = BTX_SOURCE_STATE_INITIALIZING;
+
+  /* Retrieve the component's private data from its user data */
+  common_data_t *common_data = bt_self_component_get_data(
+      bt_self_message_iterator_borrow_component(self_message_iterator));
+
+  /* Save a link to the self_message_iterator */
+  common_data->self_message_iterator = self_message_iterator;
+
+  /* Keep a link to the component's private data */
+  message_iterator_private_data->common_data = common_data;
+
+  /* Set the message iterator's user data to our private data structure */
+  bt_self_message_iterator_set_data(self_message_iterator,
+                                    message_iterator_private_data);
+
+  return BT_MESSAGE_ITERATOR_CLASS_INITIALIZE_METHOD_STATUS_OK;
+}
+
+static void source_finalize(bt_self_component_source *self_component_source) {
+  common_data_t *common_data = bt_self_component_get_data(
+      bt_self_component_source_as_self_component(self_component_source));
+  // We allocate it, we need to free it
+  free(common_data->btx_params);
+  bt_value_put_ref(common_data->params);
+  free(common_data);
+}
+
+static void source_message_iterator_finalize(
+    bt_self_message_iterator *self_message_iterator) {
+  /* Retrieve our private data from the message iterator's user data */
+  btx_message_iterator_t *message_iterator_private_data =
+      bt_self_message_iterator_get_data(self_message_iterator);
+
+  struct el *elt, *tmp;
+  DL_FOREACH_SAFE(message_iterator_private_data->pool, elt, tmp) {
+    DL_DELETE(message_iterator_private_data->pool, elt);
+    free(elt);
+  }
+
+  /* Free the allocated structure */
+  free(message_iterator_private_data);
+}
+
+/* Mandatory */
+BT_PLUGIN_MODULE();
+
+BT_PLUGIN(<%= options[:plugin_name] %>);
+BT_PLUGIN_SOURCE_COMPONENT_CLASS(<%= options[:component_name] %>,
+                                 source_message_iterator_next);
+
+BT_PLUGIN_SOURCE_COMPONENT_CLASS_INITIALIZE_METHOD(<%= options[:component_name] %>,
+                                                   source_initialize);
+BT_PLUGIN_SOURCE_COMPONENT_CLASS_FINALIZE_METHOD(<%= options[:component_name] %>,
+                                                 source_finalize);
+BT_PLUGIN_SOURCE_COMPONENT_CLASS_MESSAGE_ITERATOR_CLASS_INITIALIZE_METHOD(
+    <%= options[:component_name] %>, source_message_iterator_initialize);
+BT_PLUGIN_SOURCE_COMPONENT_CLASS_MESSAGE_ITERATOR_CLASS_FINALIZE_METHOD(
+    <%= options[:component_name] %>, source_message_iterator_finalize);

data/template/upstream.c.erb

@@ -0,0 +1,47 @@
+#include "utarray.h"
+#include "uthash.h"
+#include <assert.h>
+#include <babeltrace2/babeltrace.h>
+#include <metababel/btx_component.h>
+#include <metababel/btx_upstream.h>
+
+<% event_dispatchers.each do |e| %>
+static void
+btx_dispatch_<%= e.name_sanitized %>(UT_array *callbacks,
+                                     common_data_t *common_data,
+                                     const bt_event *<%= event_name %>) {
+
+  <% e.args.each do |s| %>
+  <%= s.type %> <%= s.name %>;
+  <% end %>
+  <%= e.body %>
+  // 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, common_data->usr_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);
+  }
+  // Add the callbacks to the array
+  utarray_push_back(s->callbacks, &callback);
+}
+<% end %>

data/template/upstream.h.erb

@@ -0,0 +1,22 @@
+#pragma once
+#include <metababel/btx_component.h>
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// Dispatcher
+typedef void(dispatcher_t)(UT_array *callbacks, common_data_t *common_data,
+                           const bt_event *message);
+
+<% event_dispatchers.each do |e| %>
+<%# The signature type of callbacks %>
+typedef void
+<%= e.name_sanitized %>_callback_f(void *btx_handle, void *usr_data,
+                                   <%= e.args.map{ |s| s.type }.join(", ") %>);
+<%# The Function who register the callbacks to the dispatcher %>
+extern void btx_register_callbacks_<%= e.name_sanitized %>(
+    void *btx_handle, <%= e.name_sanitized %>_callback_f *callback);
+<% end %>
+#ifdef __cplusplus
+}
+#endif

metadata

@@ -0,0 +1,62 @@
+--- !ruby/object:Gem::Specification
+name: metababel
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+platform: ruby
+authors:
+- Thomas Applencourt
+- Aurelio A. Vivas Meza
+- Brice Videau
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2023-04-20 00:00:00.000000000 Z
+dependencies: []
+description: 
+email: 
+executables:
+- metababel
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- bin/metababel
+- lib/metababel.rb
+- lib/metababel/bt2_generator_utils.rb
+- lib/metababel/bt2_stream_classes_generator.rb
+- lib/metababel/bt2_values_generator.rb
+- lib/metababel/version.rb
+- template/component.c.erb
+- template/component.h.erb
+- template/downstream.c.erb
+- template/downstream.h.erb
+- template/filter.c.erb
+- template/metababel.h.erb
+- template/sink.c.erb
+- template/source.c.erb
+- template/upstream.c.erb
+- template/upstream.h.erb
+homepage: 
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.2
+signing_key: 
+specification_version: 4
+summary: Helper for creation Babeltrace plugins
+test_files: []