metababel 0.0.3 → 0.0.5

data/template/filter.c.erb

@@ -9,44 +9,46 @@
  * https://babeltrace.org/docs/v2.0/libbabeltrace2/example-simple-flt-cmp-cls.html
  */
 
-static char *get_port_name(uint64_t current) {
-  int num_len = snprintf(NULL, 0, "in%ld", current);
-  char *result = (char *)malloc(num_len + 1);
-  sprintf(result, "in%ld", current);
-  return result;
-}
-
 /*
- *  Handle Upstream Messages
+ *   _____ _        _        ___  ___           _     _
+ *  /  ___| |      | |       |  \/  |          | |   (_)
+ *  \ `--.| |_ __ _| |_ ___  | .  . | __ _  ___| |__  _ _ __   ___  ___
+ *   `--. \ __/ _` | __/ _ \ | |\/| |/ _` |/ __| '_ \| | '_ \ / _ \/ __|
+ *  /\__/ / || (_| | ||  __/ | |  | | (_| | (__| | | | | | | |  __/\__ \
+ *  \____/ \__\__,_|\__\___| \_|  |_/\__,_|\___|_| |_|_|_| |_|\___||___/
  */
 
+/*    _
+ *   |_ o ._   _. | o _   _
+ *   |  | | | (_| | | /_ (/_
+ */
 static inline bt_message_iterator_class_next_method_status
-filter_message_iterator_next_initializing(
+filter_message_iterator_next_finalizing(
     bt_self_message_iterator *self_message_iterator,
     bt_message_array_const messages, uint64_t capacity, uint64_t *count) {
-  /* 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);
 
-  /* 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);
-
-  // We need to transition in the procesing state
-  message_iterator_private_data->state = BTX_FILTER_STATE_PROCESSING;
-  if (message_iterator_private_data->queue)
-    message_iterator_private_data->processing_state =
-        BTX_FILTER_PROCESSING_STATE_SENDING;
-
-  return BT_MESSAGE_ITERATOR_CLASS_NEXT_METHOD_STATUS_AGAIN;
+  /* No more messages, we can stop the plugin, and transition to END  */
+  if (!message_iterator_private_data->queue) {
+    message_iterator_private_data->state = BTX_FILTER_STATE_FINISHED;
+    return BT_MESSAGE_ITERATOR_CLASS_NEXT_METHOD_STATUS_END;
+  }
+  /* Still some message, because we moved message, we can send
+     BT_MESSAGE_ITERATOR_CLASS_NEXT_METHOD_STATUS_OK, and we will be recalled
+     latter by BT
+   */
+  btx_downstream_move_messages(message_iterator_private_data, messages,
+                               capacity, count);
+  return BT_MESSAGE_ITERATOR_CLASS_NEXT_METHOD_STATUS_OK;
 }
 
+/*    _                                  __
+ *   |_) ._ _   _  _   _  _ o ._   _    (_   _  ._   _| o ._   _
+ *   |   | (_) (_ (/_ _> _> | | | (_|   __) (/_ | | (_| | | | (_|
+ *                                 _|                          _|
+ */
 static inline bt_message_iterator_class_next_method_status
 filter_message_iterator_next_processing_sending(
     bt_self_message_iterator *self_message_iterator,
@@ -55,9 +57,19 @@ filter_message_iterator_next_processing_sending(
   btx_message_iterator_t *message_iterator_private_data =
       bt_self_message_iterator_get_data(self_message_iterator);
 
+  /* This should never append. When transitioning to sending,
+     we check that we have some messages to send */
+  if (!message_iterator_private_data->queue) {
+    message_iterator_private_data->state = BTX_FILTER_STATE_ERROR;
+    return BT_MESSAGE_ITERATOR_CLASS_NEXT_METHOD_STATUS_ERROR;
+  }
+
   btx_downstream_move_messages(message_iterator_private_data, messages,
                                capacity, count);
 
+  /* No more messages to send; we can transition back to reading
+     If not, this function will be called again
+     in order to minimize memory usage */
   if (!message_iterator_private_data->queue) {
     message_iterator_private_data->processing_state =
         BTX_FILTER_PROCESSING_STATE_READING;
@@ -65,109 +77,172 @@ filter_message_iterator_next_processing_sending(
   return BT_MESSAGE_ITERATOR_CLASS_NEXT_METHOD_STATUS_OK;
 }
 
-static inline bt_message_iterator_class_next_method_status
-filter_message_iterator_next_processing_reading(
-    bt_self_message_iterator *self_message_iterator,
-    bt_message_array_const messages, uint64_t capacity, uint64_t *count) {
-  /* 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);
+/*    _                                  _
+ *   |_) ._ _   _  _   _  _ o ._   _    |_)  _   _.  _| o ._   _
+ *   |   | (_) (_ (/_ _> _> | | | (_|   | \ (/_ (_| (_| | | | (_|
+ *                                 _|                          _|
+ */
+static inline bool filter_message_iterator_next_unregister(
+    btx_message_iterator_t *message_iterator_private_data) {
+
+  /* Unregister from BT */
+  bt_message_iterator_put_ref(
+      message_iterator_private_data->head_mi->message_iterator);
+  /* Delete from our ring buffer */
+  struct el_mi *tmp = message_iterator_private_data->head_mi;
+  CDL_DELETE(message_iterator_private_data->head_mi, tmp);
+  free(tmp);
+  /* Return if empty or not */
+  return message_iterator_private_data->head_mi;
+}
+
+static inline void filter_message_iterator_next_call_dispatchers(
+    const bt_message *upstream_message,
+    btx_message_iterator_t *message_iterator_private_data) {
 
   common_data_t *common_data = message_iterator_private_data->common_data;
+  /* Borrow the event message's event and its class */
+  const bt_event *event = bt_message_event_borrow_event_const(upstream_message);
+  const bt_event_class *event_class = bt_event_borrow_class_const(event);
+  /* Lazy modified variable */
+  bool is_callback_called = false;
+  /* Event dispatcher */
+  {
+    const char *class_name = bt_event_class_get_name(event_class);
+    name_to_dispatcher_t *s = NULL;
+    HASH_FIND_STR(common_data->name_to_dispatcher, class_name, s);
+    if (s)
+      (*((dispatcher_t(*))(s->dispatcher)))(
+          s->callbacks, common_data, upstream_message, &is_callback_called);
+  }
+  /* Matching Dispacher */
+  {
+    const bt_stream_class *stream_class =
+        bt_event_class_borrow_stream_class_const(event_class);
+    const char *stream_class_name = bt_stream_class_get_name(stream_class);
 
-  /* Consume a batch of messages from the upstream message iterator */
-  uint64_t upstream_message_count;
-  bt_message_array_const upstream_messages;
+    name_to_dispatcher_t *s = NULL;
+    if (stream_class_name)
+      HASH_FIND_STR(common_data->name_to_matching_dispatcher,
+                    stream_class_name, s);
+    if (s)
+      (*((dispatcher_t(*))(s->dispatcher)))(
+          s->callbacks, common_data, upstream_message, &is_callback_called);
+  }
+  /* Drop or push upstream message*/
+  if (is_callback_called) {
+    bt_message_put_ref(upstream_message);
+  } else {
+    btx_downstream_push_message(message_iterator_private_data,
+                                upstream_message);
+  }
+}
 
-  bt_message_iterator_next_status next_status = bt_message_iterator_next(
-      message_iterator_private_data->head_mi->message_iterator,
-      &upstream_messages, &upstream_message_count);
+static inline void
+filter_message_iterator_next_processing_reading_to_finalizing(
+    bt_self_message_iterator *self_message_iterator,
+    btx_message_iterator_t *message_iterator_private_data) {
+  /* 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);
 
-  /* We cannot have any message left in the downstream queue
-   * Hence it's safe to pass any error messages downstream.
-   */
-  switch (next_status) {
-  case BT_MESSAGE_ITERATOR_NEXT_STATUS_END:
-    /* We are setting the state, so this function will never being call twice */
-    bt_message_iterator_put_ref(
-        message_iterator_private_data->head_mi->message_iterator);
-    struct el_mi *tmp = message_iterator_private_data->head_mi;
-    CDL_DELETE(message_iterator_private_data->head_mi, tmp);
-    free(tmp);
-
-    if (!message_iterator_private_data->head_mi) {
-      /* Call Finalize user callback */
-      btx_call_callbacks_finalize_usr_data(
-          message_iterator_private_data->common_data,
-          message_iterator_private_data->common_data->usr_data);
-      message_iterator_private_data->state = BTX_FILTER_STATE_FINALIZING;
-      message_iterator_private_data->processing_state =
-          BTX_FILTER_PROCESSING_STATE_FINISHED;
-    }
-    return BT_MESSAGE_ITERATOR_CLASS_NEXT_METHOD_STATUS_AGAIN;
-  case BT_MESSAGE_ITERATOR_NEXT_STATUS_AGAIN:
-    return BT_MESSAGE_ITERATOR_CLASS_NEXT_METHOD_STATUS_AGAIN;
-  case BT_MESSAGE_ITERATOR_NEXT_STATUS_MEMORY_ERROR:
-    message_iterator_private_data->state = BTX_FILTER_STATE_ERROR;
-    return BT_MESSAGE_ITERATOR_CLASS_NEXT_METHOD_STATUS_MEMORY_ERROR;
-  case BT_MESSAGE_ITERATOR_NEXT_STATUS_ERROR:
-    message_iterator_private_data->state = BTX_FILTER_STATE_ERROR;
-    return BT_MESSAGE_ITERATOR_CLASS_NEXT_METHOD_STATUS_ERROR;
-  case BT_MESSAGE_ITERATOR_NEXT_STATUS_OK:
-    break;
-  default:
-    message_iterator_private_data->state = BTX_FILTER_STATE_ERROR;
-    return BT_MESSAGE_ITERATOR_CLASS_NEXT_METHOD_STATUS_ERROR;
-  }
+  /* Transition to switch */
+  message_iterator_private_data->state = BTX_FILTER_STATE_FINALIZING;
+  message_iterator_private_data->processing_state =
+      BTX_FILTER_PROCESSING_STATE_FINISHED;
+}
 
+static inline void filter_message_iterator_next_processing_reading_callbacks(
+    btx_message_iterator_t *message_iterator_private_data,
+    common_data_t *common_data, uint64_t upstream_message_count,
+    bt_message_array_const upstream_messages) {
   /* For each consumed message */
   for (uint64_t upstream_i = 0; upstream_i < upstream_message_count;
        upstream_i++) {
     /* Current message */
     const bt_message *upstream_message = upstream_messages[upstream_i];
-    /* Move as is if it's not an event message */
+    /* Forward all non-event-messages downstream */
     if (bt_message_get_type(upstream_message) != BT_MESSAGE_TYPE_EVENT) {
-      bt_message_put_ref(upstream_message);
-      continue;
-    }
-    /* Borrow the event message's event and its class */
-    const bt_event *event =
-        bt_message_event_borrow_event_const(upstream_message);
-    const bt_event_class *event_class = bt_event_borrow_class_const(event);
-
-    /* Call dispatcher or forward message downstream */
-    name_to_dispatcher_t *s = NULL;
-    const char *class_name = bt_event_class_get_name(event_class);
-    HASH_FIND_STR(common_data->name_to_dispatcher, class_name, s);
-    if (s) {
-      (*((dispatcher_t(*))(s->dispatcher)))(s->callbacks, common_data, event);
-      /* The message have been consumed, we can discard it */
-      bt_message_put_ref(upstream_message);
-    } else {
       btx_downstream_push_message(message_iterator_private_data,
                                   upstream_message);
+    } else {
+      filter_message_iterator_next_call_dispatchers(
+          upstream_message, message_iterator_private_data);
     }
   }
+}
 
-  /* Round Robin between Upstream MessageIterator */
-  message_iterator_private_data->head_mi =
-      message_iterator_private_data->head_mi->next;
+static inline bt_message_iterator_class_next_method_status
+filter_message_iterator_next_processing_reading(
+    bt_self_message_iterator *self_message_iterator,
+    bt_message_array_const messages, uint64_t capacity, uint64_t *count) {
+  /* 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);
 
-  if (message_iterator_private_data->queue) {
-    message_iterator_private_data->processing_state =
-        BTX_FILTER_PROCESSING_STATE_SENDING;
-    /* optimization */
-    return filter_message_iterator_next_processing_sending(
-        self_message_iterator, messages, capacity, count);
-  } else
-    return BT_MESSAGE_ITERATOR_CLASS_NEXT_METHOD_STATUS_AGAIN;
+  common_data_t *common_data = message_iterator_private_data->common_data;
+
+  while (!message_iterator_private_data->queue) {
+    /* Consume a batch of messages from the upstream message iterator */
+    uint64_t upstream_message_count;
+    bt_message_array_const upstream_messages;
+
+    bt_message_iterator_next_status next_status = bt_message_iterator_next(
+        message_iterator_private_data->head_mi->message_iterator,
+        &upstream_messages, &upstream_message_count);
+
+    switch (next_status) {
+    case BT_MESSAGE_ITERATOR_NEXT_STATUS_OK:
+      filter_message_iterator_next_processing_reading_callbacks(
+          message_iterator_private_data, common_data, upstream_message_count,
+          upstream_messages);
+      /* Round Robin between Upstream MessageIterator */
+      message_iterator_private_data->head_mi =
+          message_iterator_private_data->head_mi->next;
+      break;
+    case BT_MESSAGE_ITERATOR_NEXT_STATUS_END:
+      if (filter_message_iterator_next_unregister(
+              message_iterator_private_data))
+        break;
+      filter_message_iterator_next_processing_reading_to_finalizing(
+          self_message_iterator, message_iterator_private_data);
+      return filter_message_iterator_next_finalizing(self_message_iterator,
+                                                     messages, capacity, count);
+    case BT_MESSAGE_ITERATOR_NEXT_STATUS_AGAIN:
+      return BT_MESSAGE_ITERATOR_CLASS_NEXT_METHOD_STATUS_AGAIN;
+    case BT_MESSAGE_ITERATOR_NEXT_STATUS_MEMORY_ERROR:
+      message_iterator_private_data->state = BTX_FILTER_STATE_ERROR;
+      return BT_MESSAGE_ITERATOR_CLASS_NEXT_METHOD_STATUS_MEMORY_ERROR;
+    case BT_MESSAGE_ITERATOR_NEXT_STATUS_ERROR:
+      message_iterator_private_data->state = BTX_FILTER_STATE_ERROR;
+      return BT_MESSAGE_ITERATOR_CLASS_NEXT_METHOD_STATUS_ERROR;
+    default:
+      message_iterator_private_data->state = BTX_FILTER_STATE_ERROR;
+      return BT_MESSAGE_ITERATOR_CLASS_NEXT_METHOD_STATUS_ERROR;
+    }
+  }
+
+  message_iterator_private_data->processing_state =
+      BTX_FILTER_PROCESSING_STATE_SENDING;
+  /* optimization to not send AGAIN */
+  return filter_message_iterator_next_processing_sending(
+      self_message_iterator, messages, capacity, count);
 }
 
+/*    _                                  __
+ *   |_) ._ _   _  _   _  _ o ._   _    (_       o _|_  _ |_
+ *   |   | (_) (_ (/_ _> _> | | | (_|   __) \/\/ |  |_ (_ | |
+ *                                 _|
+ */
 static inline bt_message_iterator_class_next_method_status
 filter_message_iterator_next_processing(
     bt_self_message_iterator *self_message_iterator,
     bt_message_array_const messages, uint64_t capacity, uint64_t *count) {
-  /* 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);
 
@@ -185,26 +260,52 @@ filter_message_iterator_next_processing(
   }
 }
 
+/*   ___
+ *    |  ._  o _|_ o  _. | o _  o ._   _
+ *   _|_ | | |  |_ | (_| | | /_ | | | (_|
+ *                                     _|
+ */
 static inline bt_message_iterator_class_next_method_status
-filter_message_iterator_next_finalizing(
+filter_message_iterator_next_initializing(
     bt_self_message_iterator *self_message_iterator,
     bt_message_array_const messages, uint64_t capacity, uint64_t *count) {
+
   /* 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);
 
-  // assert(message_iterator_private_data->processing_state ==
-  // BTX_FILTER_PROCESSING_STATE_FINISHED);
-  if (!message_iterator_private_data->queue) {
-    message_iterator_private_data->state = BTX_FILTER_STATE_FINISHED;
-    return BT_MESSAGE_ITERATOR_CLASS_NEXT_METHOD_STATUS_END;
-  }
+  /* Begining of Stream */
+  btx_push_messages_stream_beginning(self_message_iterator,
+                                     message_iterator_private_data);
 
-  btx_downstream_move_messages(message_iterator_private_data, messages,
-                               capacity, count);
-  return BT_MESSAGE_ITERATOR_CLASS_NEXT_METHOD_STATUS_OK;
+  /* 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);
+
+  /* We need to transition to the processing state*/
+  message_iterator_private_data->state = BTX_FILTER_STATE_PROCESSING;
+  if (message_iterator_private_data->queue) {
+    message_iterator_private_data->processing_state =
+        BTX_FILTER_PROCESSING_STATE_SENDING;
+  } else {
+    message_iterator_private_data->processing_state =
+        BTX_FILTER_PROCESSING_STATE_READING;
+  }
+  return filter_message_iterator_next_processing(self_message_iterator,
+                                                 messages, capacity, count);
 }
 
+/*    _                                     __
+ *   /   _  ._ _  ._   _  ._   _  ._ _|_   (_       o _|_  _ |_
+ *   \_ (_) | | | |_) (_) | | (/_ | | |_   __) \/\/ |  |_ (_ | |
+ *                |
+ */
 static bt_message_iterator_class_next_method_status
 filter_message_iterator_next(bt_self_message_iterator *self_message_iterator,
                              bt_message_array_const messages, uint64_t capacity,
@@ -231,9 +332,22 @@ filter_message_iterator_next(bt_self_message_iterator *self_message_iterator,
   }
 }
 
-/*
- * Initializes the filter component.
+/*   _____                                              _
+ *  /  __ \                                            | |
+ *  | /  \/ ___  _ __ ___  _ __   ___  _ __   ___ _ __ | |_
+ *  | |    / _ \| '_ ` _ \| '_ \ / _ \| '_ \ / _ \ '_ \| __|
+ *  | \__/\ (_) | | | | | | |_) | (_) | | | |  __/ | | | |_
+ *   \____/\___/|_| |_| |_| .__/ \___/|_| |_|\___|_| |_|\__|
+ *                        | |
+ *                        |_|
  */
+static char *_btx_get_port_name(uint64_t current) {
+  int num_len = snprintf(NULL, 0, "in%ld", current);
+  char *result = (char *)malloc(num_len + 1);
+  sprintf(result, "in%ld", current);
+  return result;
+}
+
 static bt_component_class_initialize_method_status
 filter_initialize(bt_self_component_filter *self_component_filter,
                   bt_self_component_filter_configuration *configuration,
@@ -243,7 +357,7 @@ filter_initialize(bt_self_component_filter *self_component_filter,
   common_data_t *common_data = calloc(1, sizeof(common_data_t));
   common_data->btx_params = calloc(1, sizeof(btx_params_t));
   common_data->params = params;
-  // Read parameters
+  /* Read parameters */
   btx_populate_params(common_data);
   bt_value_get_ref(common_data->params);
 
@@ -276,19 +390,18 @@ filter_initialize(bt_self_component_filter *self_component_filter,
   const uint64_t current =
       bt_component_filter_get_input_port_count(common_data->component);
 
-  {
-    char *name = get_port_name(current);
-    bt_self_component_filter_add_input_port(self_component_filter, name, NULL,
-                                            NULL);
-    free(name);
-  }
+  char *name = _btx_get_port_name(current);
+  bt_self_component_filter_add_input_port(self_component_filter, name, NULL,
+                                          NULL);
+  free(name);
+
   bt_self_component_filter_add_output_port(self_component_filter, "out", NULL,
                                            NULL);
 
-  /* Create message that will be used by the filter */
+  /* Create message classes that will be used by the filter */
   bt_self_component *self_component =
       bt_self_component_filter_as_self_component(self_component_filter);
-  /* Create a `trace_class` and all the children classes (stream and events) */
+  /* Create a `trace_class` and all the children's classes (stream and events) */
   bt_trace_class *trace_class =
       btx_downstream_trace_class_create_rec(self_component);
   /* Instantiate a `downstream_trace` of `trace_class` and all the children
@@ -304,15 +417,14 @@ bt_component_class_port_connected_method_status
 filter_input_port_connected(bt_self_component_filter *self_component_filter,
                             bt_self_component_port_input *self_port,
                             const bt_port_output *other_port) {
+
   const uint64_t current = bt_component_filter_get_input_port_count(
       bt_self_component_filter_as_component_filter(self_component_filter));
 
-  {
-    char *name = get_port_name(current);
-    bt_self_component_filter_add_input_port(self_component_filter, name, NULL,
-                                            NULL);
-    free(name);
-  }
+  char *name = _btx_get_port_name(current);
+  bt_self_component_filter_add_input_port(self_component_filter, name, NULL,
+                                          NULL);
+  free(name);
 
   return BT_COMPONENT_CLASS_PORT_CONNECTED_METHOD_STATUS_OK;
 }
@@ -365,9 +477,6 @@ filter_message_iterator_initialize(
                                     message_iterator_private_data);
 
   message_iterator_private_data->state = BTX_FILTER_STATE_INITIALIZING;
-  message_iterator_private_data->processing_state =
-      BTX_FILTER_PROCESSING_STATE_READING;
-
   return BT_MESSAGE_ITERATOR_CLASS_INITIALIZE_METHOD_STATUS_OK;
 }
 
@@ -376,18 +485,14 @@ static void filter_finalize(bt_self_component_filter *self_component_filter) {
       bt_self_component_filter_as_self_component(self_component_filter));
 
   btx_streams_put_ref(common_data->downstream_trace); // ??
-  // We allocate it, we need to put ref
+  /* We allocate it, we need to put ref */
   bt_trace_put_ref(common_data->downstream_trace);
 
-  // Delete name_to_dispatcher
-  name_to_dispatcher_t *current, *tmp;
-  HASH_ITER(hh, common_data->name_to_dispatcher, current, tmp) {
-    HASH_DEL(common_data->name_to_dispatcher, current);
-    utarray_free(current->callbacks);
-    free(current);
-  }
+  /* Delete name_to_dispatchers */
+  btx_delete_dispatchers(common_data);
+  btx_delete_matching_dispatchers(common_data);
 
-  // We allocate it, we need to free it
+  /* We allocate it, we need to free it */
   free(common_data->btx_params);
   bt_value_put_ref(common_data->params);
   free(common_data);

data/template/sink.c.erb

@@ -48,24 +48,47 @@ sink_consume(bt_self_component_sink *self_component_sink) {
   }
   /* For each consumed message */
   for (uint64_t i = 0; i < message_count; i++) {
-    const bt_message *message = messages[i];
-    if (bt_message_get_type(message) != BT_MESSAGE_TYPE_EVENT) {
-      bt_message_put_ref(message);
+    const bt_message *upstream_message = messages[i];
+    if (bt_message_get_type(upstream_message) != BT_MESSAGE_TYPE_EVENT) {
+      bt_message_put_ref(upstream_message);
       continue;
     }
 
     /* Borrow the event message's event and its class */
-    const bt_event *event = bt_message_event_borrow_event_const(message);
+    const bt_event *event = bt_message_event_borrow_event_const(upstream_message);
     const bt_event_class *event_class = bt_event_borrow_class_const(event);
 
     /* Call dispatcher */
-    name_to_dispatcher_t *s = NULL;
+    bool is_callback_called = false;
     const char *class_name = bt_event_class_get_name(event_class);
-    HASH_FIND_STR(common_data->name_to_dispatcher, class_name, s);
-    if (s)
-      (*((dispatcher_t(*))(s->dispatcher)))(s->callbacks, common_data, event);
 
-    bt_message_put_ref(message);
+    {
+      name_to_dispatcher_t *s = NULL;
+      HASH_FIND_STR(common_data->name_to_dispatcher, class_name, s);
+      if (s) {
+        (*((dispatcher_t(*))(s->dispatcher)))(s->callbacks, common_data, upstream_message,
+                                              &is_callback_called);
+      }
+    }
+
+    {
+      const bt_stream_class *stream_class =
+          bt_event_class_borrow_stream_class_const(event_class);
+      const char *stream_class_name = bt_stream_class_get_name(stream_class);
+
+      name_to_dispatcher_t *s = NULL;
+      if (stream_class_name)
+        HASH_FIND_STR(common_data->name_to_matching_dispatcher, stream_class_name,
+                      s);
+      if (s) {
+        // is_callback_called will only be modified if at least one callback is
+        // called.
+        (*((dispatcher_t(*))(s->dispatcher)))(s->callbacks, common_data, upstream_message,
+                                              &is_callback_called);
+      }
+    }
+
+    bt_message_put_ref(upstream_message);
   }
 end:
   return status;
@@ -122,12 +145,8 @@ static void sink_finalize(bt_self_component_sink *self_component_sink) {
   btx_call_callbacks_finalize_usr_data(common_data, common_data->usr_data);
 
   // Delete name_to_dispatcher
-  name_to_dispatcher_t *current, *tmp;
-  HASH_ITER(hh, common_data->name_to_dispatcher, current, tmp) {
-    HASH_DEL(common_data->name_to_dispatcher, current);
-    utarray_free(current->callbacks);
-    free(current);
-  }
+  btx_delete_dispatchers(common_data);
+  btx_delete_matching_dispatchers(common_data);
 
   // We allocate it, we need to free it
   free(common_data->btx_params);