Added functional unit test case for verifying feature arc control plane
and fast path APIs
How to run:
$ echo "graph_feature_arc_autotest" | ./bin/dpdk-test
Signed-off-by: Nitin Saxena <nsax...@marvell.com>
---
app/test/meson.build | 1 +
app/test/test_graph_feature_arc.c | 1374 +++++++++++++++++++++++++++++
2 files changed, 1375 insertions(+)
create mode 100644 app/test/test_graph_feature_arc.c
diff --git a/app/test/meson.build b/app/test/meson.build
index b6285a6b45..acb0d36c6b 100644
--- a/app/test/meson.build
+++ b/app/test/meson.build
@@ -90,6 +90,7 @@ source_file_deps = {
'test_func_reentrancy.c': ['hash', 'lpm'],
'test_graph.c': ['graph'],
'test_graph_perf.c': ['graph'],
+ 'test_graph_feature_arc.c': ['graph'],
'test_hash.c': ['net', 'hash'],
'test_hash_functions.c': ['hash'],
'test_hash_multiwriter.c': ['hash'],
diff --git a/app/test/test_graph_feature_arc.c
b/app/test/test_graph_feature_arc.c
new file mode 100644
index 0000000000..b46ab4457e
--- /dev/null
+++ b/app/test/test_graph_feature_arc.c
@@ -0,0 +1,1374 @@
+/* SPDX-License-Identifier: BSD-3-Clause
+ * Copyright(C) 2024 Marvell International Ltd.
+ */
+
+#include "test.h"
+
+#include <assert.h>
+#include <inttypes.h>
+#include <signal.h>
+#include <stdalign.h>
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+
+#include <rte_errno.h>
+
+#ifndef RTE_EXEC_ENV_WINDOWS
+#include <rte_graph.h>
+#include <rte_graph_worker.h>
+#include <rte_mbuf.h>
+#include <rte_mbuf_dyn.h>
+#include <rte_random.h>
+#include <rte_graph_feature_arc.h>
+#include <rte_graph_feature_arc_worker.h>
+
+#define MBUF_NUM 256
+#define TEST_ARC1_NAME "arc1"
+#define TEST_ARC2_NAME "arc2"
+#define TEST_FAILED_ARC "failed_arc"
+#define MAX_INDEXES 10
+#define OVERRIDE_MAX_INDEX MBUF_NUM
+#define MAX_FEATURES 5
+
+#define dbg(...)
+
+#define SOURCE1 "arc_source1_node"
+#define INPUT_STATIC "arc_input_static_node"
+#define OUTPUT_STATIC "arc_output_static_node"
+#define PKT_FREE_STATIC "arc_pkt_free_static_node"
+#define ARC1_FEATURE1 "arc1_feature1_node"
+#define ARC1_FEATURE2 "arc1_feature2_node"
+#define ARC2_FEATURE1 "arc2_feature1_node"
+#define ARC2_FEATURE2 "arc2_feature2_node"
+#define ARC2_FEATURE3 "arc2_feature3_node"
+#define DUMMY1_STATIC "arc_dummy1_static_node"
+#define DUMMY2_STATIC "arc_dummy2_static_node"
+
+#define feature_cast(x) ((rte_graph_feature_t)(x))
+
+/* (Node index, Node Name, feature app_cookie base */
+#define FOREACH_TEST_NODE_ARC { \
+ R(0, SOURCE1, 64) \
+ R(1, INPUT_STATIC, 128) \
+ R(2, OUTPUT_STATIC, 256) \
+ R(3, PKT_FREE_STATIC, 512) \
+ R(4, ARC1_FEATURE1, 1024) \
+ R(5, ARC1_FEATURE2, 2048) \
+ R(6, ARC2_FEATURE1, 4096) \
+ R(7, ARC2_FEATURE2, 8192) \
+ R(8, ARC2_FEATURE3, 16384) \
+ R(9, DUMMY1_STATIC, 32768) \
+ R(10, DUMMY2_STATIC, 65536) \
+ }
+
+/**
+ * ARC1: Feature arc on ingress interface
+ * ARC2: Feature arc on egress interface
+ * XX_static: Static nodes
+ * XX_featureX: Feature X on arc
+ *
+ * -----> ARC1_FEATURE1
+ * | | |
+ * | | v
+ * | | ARC1_FEATURE2
+ * | | |
+ * | v v
+ * SOURCE1 ->-----> INPUT_STATIC --> OUTPUT_STATIC -----> PKT_FREE_STATIC
+ * | | | ^ ^ ^
+ * | | | | | |
+ * | | --> ARC2_FEATURE1 | |
+ * | | ^ ^ | |
+ * | | | | | |
+ * | ----------c-> ARC2_FEATURE2 |
+ * | | ^ |
+ * | | | |
+ * ----------> ARC2_FEATURE3 -------
+ */
+const char *node_names_feature_arc[] = {
+ SOURCE1, INPUT_STATIC, OUTPUT_STATIC, PKT_FREE_STATIC,
+ ARC1_FEATURE1, ARC1_FEATURE2, ARC2_FEATURE1, ARC2_FEATURE2,
ARC2_FEATURE3,
+ DUMMY1_STATIC, DUMMY2_STATIC
+};
+
+const char *arc_names[] = {
+ TEST_ARC1_NAME, TEST_ARC2_NAME,
+};
+
+const char *arc1_feature_seq[] = {
+ ARC1_FEATURE1, ARC1_FEATURE2, INPUT_STATIC,
+};
+
+const char *arc2_feature_seq[] = {
+ ARC2_FEATURE1, ARC2_FEATURE2, ARC2_FEATURE3, PKT_FREE_STATIC,
+};
+
+#define MAX_NODES RTE_DIM(node_names_feature_arc)
+
+typedef enum {
+ START_NODE,
+ INTERMEDIATE_FEATURE,
+ END_FEATURE,
+} fp_node_type_t;
+
+static int fp_test_case_result_failed;
+static const char *fp_error_node;
+static uint64_t fp_end_feature_counters;
+static uint64_t sp_enable_counters, sp_enable_cb_counters;
+static uint64_t sp_disable_counters, sp_disable_cb_counters;
+
+/* Function declarations */
+static uint16_t
+source1_fn(struct rte_graph *graph, struct rte_node *node,
+ void **objs, uint16_t nb_objs);
+static uint16_t
+input_fa_fn(struct rte_graph *graph, struct rte_node *node,
+ void **objs, uint16_t nb_objs);
+static uint16_t
+output_fa_fn(struct rte_graph *graph, struct rte_node *node,
+ void **objs, uint16_t nb_objs);
+static uint16_t
+pkt_free_fn(struct rte_graph *graph, struct rte_node *node,
+ void **objs, uint16_t nb_objs);
+static uint16_t
+pkt_free_fa_fn(struct rte_graph *graph, struct rte_node *node,
+ void **objs, uint16_t nb_objs);
+static uint16_t
+dummy1_fn(struct rte_graph *graph, struct rte_node *node,
+ void **objs, uint16_t nb_objs);
+static uint16_t
+dummy2_fn(struct rte_graph *graph, struct rte_node *node,
+ void **objs, uint16_t nb_objs);
+static uint16_t
+arc1_feature1_fn(struct rte_graph *graph, struct rte_node *node,
+ void **objs, uint16_t nb_objs);
+static uint16_t
+arc1_feature1_fa_fn(struct rte_graph *graph, struct rte_node *node,
+ void **objs, uint16_t nb_objs);
+static uint16_t
+arc1_feature2_fa_fn(struct rte_graph *graph, struct rte_node *node,
+ void **objs, uint16_t nb_objs);
+static uint16_t
+arc2_feature1_fa_fn(struct rte_graph *graph, struct rte_node *node,
+ void **objs, uint16_t nb_objs);
+static uint16_t
+arc2_feature2_fa_fn(struct rte_graph *graph, struct rte_node *node,
+ void **objs, uint16_t nb_objs);
+static uint16_t
+arc2_feature3_fa_fn(struct rte_graph *graph, struct rte_node *node,
+ void **objs, uint16_t nb_objs);
+static int
+common_arc1_init(const struct rte_graph *graph, struct rte_node *node);
+static int
+common_arc2_init(const struct rte_graph *graph, struct rte_node *node);
+static uint16_t
+common_process_fn(struct rte_graph *graph, struct rte_node *node,
+ void **objs, uint16_t nb_objs, uint16_t max_indexes,
+ uint16_t mbuf_arr_offset, fp_node_type_t type);
+
+typedef struct test_node_priv {
+ int stop_enqueue;
+
+ /* rte_graph node id */
+ uint32_t node_id;
+
+ rte_graph_feature_arc_t arc;
+} test_node_priv_t;
+
+typedef struct {
+ rte_graph_feature_t feature;
+ uint16_t egress_interface;
+ uint16_t ingress_interface;
+} graph_dynfield_t;
+
+#define MAX_FEATURE_ARCS 4
+static rte_graph_feature_arc_t arcs[MAX_FEATURE_ARCS];
+static struct rte_mbuf mbufs[MAX_NODES + 1][MBUF_NUM];
+static void *mbuf_p[MAX_NODES + 1][MBUF_NUM];
+static rte_graph_t graph_id = RTE_GRAPH_ID_INVALID;
+
+static uint16_t
+compute_unique_user_data(const char *parent, const char *child, uint32_t
interface_index)
+{
+ uint16_t user_data = interface_index;
+
+ RTE_SET_USED(parent);
+#define R(idx, node, node_cookie) { \
+ if (!strcmp(child, node)) { \
+ user_data += node_cookie + idx; \
+ } \
+ }
+
+ FOREACH_TEST_NODE_ARC
+#undef R
+
+ return user_data;
+}
+
+static void update_sp_counters(const char *arc_name, const char *feature_name,
+ rte_node_t feature_node_id, uint32_t index,
+ bool enable_disable, uint16_t app_cookie)
+
+{
+ RTE_SET_USED(feature_node_id);
+
+ if (app_cookie != UINT16_MAX) {
+ if (app_cookie != compute_unique_user_data(arc_name,
feature_name, index)) {
+ printf("cb():%s/%s/%u: app_cookie mismatch %u != %u\n",
+ arc_name, feature_name, index, app_cookie,
+ compute_unique_user_data(arc_name, feature_name,
index));
+ sp_enable_counters = UINT16_MAX;
+ sp_disable_counters = UINT16_MAX;
+ }
+ }
+ if (enable_disable)
+ sp_enable_cb_counters++;
+ else
+ sp_disable_cb_counters++;
+}
+
+
+
+static int
+get_edge(struct rte_node_register *parent_node,
+ struct rte_node_register *child_node, rte_edge_t *_edge)
+{
+ char **next_edges = NULL;
+ uint32_t count, i;
+
+ count = rte_node_edge_get(parent_node->id, NULL);
+
+ if (!count)
+ return -1;
+
+ next_edges = malloc(count);
+
+ if (!next_edges)
+ return -1;
+
+ count = rte_node_edge_get(parent_node->id, next_edges);
+ for (i = 0; i < count; i++) {
+ if (strstr(child_node->name, next_edges[i])) {
+ if (_edge)
+ *_edge = (rte_edge_t)i;
+
+ free(next_edges);
+ return 0;
+ }
+ }
+ free(next_edges);
+
+ return -1;
+}
+
+int
+common_arc1_init(const struct rte_graph *graph, struct rte_node *node)
+{
+ test_node_priv_t *priv = (test_node_priv_t *)node->ctx;
+
+ RTE_SET_USED(graph);
+
+ priv->node_id = node->id;
+ priv->stop_enqueue = 0;
+ if (rte_graph_feature_arc_lookup_by_name(TEST_ARC1_NAME, &priv->arc) <
0)
+ return -1;
+
+ return 0;
+}
+
+int
+common_arc2_init(const struct rte_graph *graph, struct rte_node *node)
+{
+ test_node_priv_t *priv = (test_node_priv_t *)node->ctx;
+
+ RTE_SET_USED(graph);
+
+ priv->node_id = node->id;
+ if (rte_graph_feature_arc_lookup_by_name(TEST_ARC2_NAME, &priv->arc) <
0)
+ return -1;
+
+ return 0;
+}
+
+uint16_t
+common_process_fn(struct rte_graph *graph, struct rte_node *node,
+ void **objs, uint16_t nb_objs, uint16_t max_indexes,
+ uint16_t mbuf_arr_offset,
+ fp_node_type_t ndtype)
+{
+ test_node_priv_t *priv = (test_node_priv_t *)node->ctx;
+ struct rte_graph_feature_arc *arc =
+ rte_graph_feature_arc_get(priv->arc);
+ struct rte_graph_feature_arc_mbuf_dynfields *mbfields = NULL;
+ struct rte_mbuf *bufs[MBUF_NUM];
+ rte_edge_t edges[MBUF_NUM];
+ uint32_t i, idx;
+
+ RTE_SET_USED(objs);
+ if (priv->stop_enqueue)
+ return 0;
+
+ if (ndtype == START_NODE)
+ nb_objs = MBUF_NUM;
+
+ for (i = 0; i < nb_objs; i++) {
+ switch (ndtype) {
+ case START_NODE:
+ edges[i] = UINT16_MAX;
+ bufs[i] = mbuf_p[mbuf_arr_offset][i];
+ break;
+ case INTERMEDIATE_FEATURE:
+ edges[i] = UINT16_MAX;
+ bufs[i] = (struct rte_mbuf *)objs[i];
+ break;
+ default:
+ edges[i] = 0;
+ bufs[i] = (struct rte_mbuf *)objs[i];
+ break;
+ }
+ mbfields = rte_graph_feature_arc_mbuf_dynfields_get(bufs[i],
arc->mbuf_dyn_offset);
+ if (ndtype == START_NODE) {
+ idx = i % max_indexes;
+ if (!rte_graph_feature_data_first_feature_get(arc, idx,
+
&mbfields->feature_data,
+
&edges[i])) {
+ fp_test_case_result_failed = 1;
+ fp_error_node = node->name;
+ priv->stop_enqueue = 1;
+ return i;
+ }
+ } else if (ndtype == INTERMEDIATE_FEATURE) {
+ if (!rte_graph_feature_data_next_feature_get(arc,
+
&mbfields->feature_data,
+
&edges[i])) {
+ fp_test_case_result_failed = 1;
+ fp_error_node = node->name;
+ return i;
+ }
+ } else {
+ /* Send pkts from arc1_end to arc2_start*/
+ if (mbuf_arr_offset == 0)
+ edges[i] = 0;
+ fp_end_feature_counters++;
+ }
+ if (edges[i] == UINT16_MAX)
+ RTE_VERIFY(0);
+ }
+ if (ndtype == START_NODE)
+ priv->stop_enqueue = 1;
+
+ if (!fp_test_case_result_failed && (!mbuf_arr_offset || (ndtype !=
END_FEATURE)))
+ rte_node_enqueue_next(graph, node, edges, (void **)bufs,
nb_objs);
+
+ return nb_objs;
+}
+
+uint16_t
+source1_fn(struct rte_graph *graph, struct rte_node *node,
+ void **objs, uint16_t nb_objs)
+{
+ return common_process_fn(graph, node, objs, nb_objs, MAX_INDEXES, 0,
START_NODE);
+}
+
+static struct rte_node_register node_source1 = {
+ .name = SOURCE1,
+ .process = source1_fn,
+ .flags = RTE_NODE_SOURCE_F,
+ .nb_edges = 3,
+ .init = common_arc1_init,
+ .next_nodes = {INPUT_STATIC, DUMMY1_STATIC, DUMMY2_STATIC},
+};
+RTE_NODE_REGISTER(node_source1);
+
+uint16_t
+input_fa_fn(struct rte_graph *graph, struct rte_node *node,
+ void **objs, uint16_t nb_objs)
+{
+ return common_process_fn(graph, node, objs, nb_objs, MAX_INDEXES, 0,
END_FEATURE);
+}
+
+static struct rte_node_register node_input = {
+ .name = INPUT_STATIC,
+ .process = input_fa_fn,
+ .nb_edges = 2,
+ .init = common_arc1_init,
+ .next_nodes = {OUTPUT_STATIC, DUMMY1_STATIC},
+};
+RTE_NODE_REGISTER(node_input);
+
+struct rte_graph_feature_register arc1_end_feature = {
+ .feature_name = INPUT_STATIC,
+ .arc_name = TEST_ARC1_NAME,
+ .feature_process_fn = input_fa_fn,
+ .feature_node = &node_input,
+ .notifier_cb = update_sp_counters,
+};
+
+static struct rte_graph_feature_arc_register arc1_input = {
+ .arc_name = TEST_ARC1_NAME,
+ .max_indexes = MAX_INDEXES,
+ .max_features = MAX_FEATURES,
+ .start_node = &node_source1,
+ .start_node_feature_process_fn = source1_fn,
+ .end_feature = &arc1_end_feature,
+};
+
+uint16_t
+output_fa_fn(struct rte_graph *graph, struct rte_node *node,
+ void **objs, uint16_t nb_objs)
+{
+ return common_process_fn(graph, node, objs, nb_objs,
+ OVERRIDE_MAX_INDEX, 1, START_NODE);
+}
+
+static struct rte_node_register node_output = {
+ .name = OUTPUT_STATIC,
+ .process = output_fa_fn,
+ .nb_edges = 3,
+ .init = common_arc2_init,
+ .next_nodes = {DUMMY1_STATIC, PKT_FREE_STATIC, DUMMY2_STATIC},
+};
+RTE_NODE_REGISTER(node_output);
+
+uint16_t
+pkt_free_fn(struct rte_graph *graph, struct rte_node *node,
+ void **objs, uint16_t nb_objs)
+{
+ RTE_SET_USED(graph);
+ RTE_SET_USED(node);
+ RTE_SET_USED(objs);
+ RTE_SET_USED(nb_objs);
+
+ fp_test_case_result_failed = 1;
+ fp_error_node = node->name;
+ return 0;
+}
+
+uint16_t
+pkt_free_fa_fn(struct rte_graph *graph, struct rte_node *node,
+ void **objs, uint16_t nb_objs)
+{
+ return common_process_fn(graph, node, objs, nb_objs,
+ OVERRIDE_MAX_INDEX, 1, END_FEATURE);
+}
+
+static struct rte_node_register node_pkt_free = {
+ .name = PKT_FREE_STATIC,
+ .process = pkt_free_fn,
+ .nb_edges = 1,
+ .init = common_arc2_init,
+ .next_nodes = {DUMMY1_STATIC},
+};
+RTE_NODE_REGISTER(node_pkt_free);
+
+static uint16_t override_arc2_index(void)
+{
+ return OVERRIDE_MAX_INDEX;
+}
+
+struct rte_graph_feature_register arc2_end_feature = {
+ .feature_name = PKT_FREE_STATIC,
+ .arc_name = TEST_ARC2_NAME,
+ .feature_process_fn = pkt_free_fa_fn,
+ .feature_node = &node_pkt_free,
+ .notifier_cb = update_sp_counters,
+};
+
+static struct rte_graph_feature_arc_register arc2_output = {
+ .arc_name = TEST_ARC2_NAME,
+ .max_indexes = 1, /* Let feature override with bigger value */
+ /* max_features not provided. End feature is a feature hence should
work*/
+ .start_node = &node_output,
+ .start_node_feature_process_fn = output_fa_fn,
+ .end_feature = &arc2_end_feature,
+};
+RTE_GRAPH_FEATURE_ARC_REGISTER(arc2_output);
+
+/** Dummy nodes */
+uint16_t
+dummy1_fn(struct rte_graph *graph, struct rte_node *node,
+ void **objs, uint16_t nb_objs)
+{
+ RTE_SET_USED(graph);
+ RTE_SET_USED(node);
+ RTE_SET_USED(objs);
+ RTE_SET_USED(nb_objs);
+ return 0;
+}
+
+static struct rte_node_register dummy1 = {
+ .name = DUMMY1_STATIC,
+ .process = dummy1_fn,
+ .nb_edges = 0,
+ .init = common_arc2_init,
+};
+RTE_NODE_REGISTER(dummy1);
+
+uint16_t
+dummy2_fn(struct rte_graph *graph, struct rte_node *node,
+ void **objs, uint16_t nb_objs)
+{
+ RTE_SET_USED(graph);
+ RTE_SET_USED(node);
+ RTE_SET_USED(objs);
+ RTE_SET_USED(nb_objs);
+ return 0;
+}
+
+static struct rte_node_register dummy2 = {
+ .name = DUMMY2_STATIC,
+ .process = dummy2_fn,
+ .nb_edges = 5,
+ .init = common_arc2_init,
+ .next_nodes = { ARC1_FEATURE1, ARC1_FEATURE2, ARC2_FEATURE1,
+ ARC2_FEATURE2, ARC2_FEATURE3},
+};
+RTE_NODE_REGISTER(dummy2);
+
+/** Failed registrations */
+
+struct rte_graph_feature_register sink_valid_feature = {
+ .feature_name = "sink_valid_feature",
+ .arc_name = TEST_FAILED_ARC,
+ .feature_process_fn = dummy2_fn,
+ .feature_node = &dummy2,
+};
+
+struct rte_graph_feature_register sink_mismatch_arc_name = {
+ .feature_name = "sink_mismatch_arc_name",
+ .arc_name = "mismatch_arc_name",
+ .feature_process_fn = dummy2_fn,
+ .feature_node = &dummy2,
+};
+
+struct rte_graph_feature_register sink_no_feature_node = {
+ .feature_name = "sink_no_feature_node",
+ .arc_name = TEST_FAILED_ARC,
+ .feature_process_fn = dummy2_fn,
+};
+
+struct rte_graph_feature_register sink_no_feature_fn = {
+ .feature_name = "sink_no_feature_fn",
+ .arc_name = TEST_FAILED_ARC,
+ .feature_node = &dummy2,
+};
+
+/* failed_arc1
+ * - max_features not provided
+ * - end_feature not provided
+ */
+static struct rte_graph_feature_arc_register failed_arc1 = {
+ .arc_name = TEST_FAILED_ARC,
+ .max_indexes = 1, /* Let features override it*/
+ /* max_features field is missing */
+ /* end_feature missing */
+ .start_node = &dummy1,
+ .start_node_feature_process_fn = dummy1_fn,
+};
+RTE_GRAPH_FEATURE_ARC_REGISTER(failed_arc1);
+
+/* failed_arc2
+ * - max_indexes not provided
+ */
+static struct rte_graph_feature_arc_register failed_arc2 = {
+ .arc_name = TEST_FAILED_ARC,
+ .end_feature = &sink_valid_feature,
+ /* max_index not provided and neither override_index_cb() in any
feature */
+ .start_node = &dummy1,
+ .start_node_feature_process_fn = dummy1_fn,
+};
+RTE_GRAPH_FEATURE_ARC_REGISTER(failed_arc2);
+
+/* failed_arc3
+ * - start_node not provided
+ */
+static struct rte_graph_feature_arc_register failed_arc3 = {
+ .arc_name = TEST_FAILED_ARC,
+ .end_feature = &sink_valid_feature,
+ .max_indexes = 1,
+ /* start_node not provided */
+ .start_node_feature_process_fn = dummy1_fn,
+};
+RTE_GRAPH_FEATURE_ARC_REGISTER(failed_arc3)
+
+/* failed_arc4
+ * - start_node not provided
+ */
+static struct rte_graph_feature_arc_register failed_arc4 = {
+ .arc_name = TEST_FAILED_ARC,
+ .end_feature = &sink_valid_feature,
+ .max_indexes = 5,
+ .start_node = &dummy1,
+ /* start_node fn not provided */
+};
+RTE_GRAPH_FEATURE_ARC_REGISTER(failed_arc4);
+
+/* failed_arc5
+ * - end_feature has mismatch arc_name
+ */
+static struct rte_graph_feature_arc_register failed_arc5 = {
+ .arc_name = TEST_FAILED_ARC,
+ .end_feature = &sink_mismatch_arc_name,
+ .max_indexes = 5,
+ .start_node = &dummy1,
+ .start_node_feature_process_fn = dummy1_fn,
+};
+RTE_GRAPH_FEATURE_ARC_REGISTER(failed_arc5);
+
+/* failed_arc6
+ * - end_feature does not have feature_node
+ */
+static struct rte_graph_feature_arc_register failed_arc6 = {
+ .arc_name = TEST_FAILED_ARC,
+ .end_feature = &sink_no_feature_node,
+ .max_indexes = 5,
+ .start_node = &dummy1,
+ .start_node_feature_process_fn = dummy1_fn,
+};
+RTE_GRAPH_FEATURE_ARC_REGISTER(failed_arc6);
+
+/* failed_arc7
+ * - end_feature does not have feature_fn
+ */
+static struct rte_graph_feature_arc_register failed_arc7 = {
+ .arc_name = TEST_FAILED_ARC,
+ .end_feature = &sink_no_feature_fn,
+ .max_indexes = 5,
+ .start_node = &dummy1,
+ .start_node_feature_process_fn = dummy1_fn,
+};
+RTE_GRAPH_FEATURE_ARC_REGISTER(failed_arc7);
+
+uint16_t
+arc1_feature1_fn(struct rte_graph *graph, struct rte_node *node,
+ void **objs, uint16_t nb_objs)
+{
+ RTE_SET_USED(graph);
+ RTE_SET_USED(node);
+ RTE_SET_USED(objs);
+ RTE_SET_USED(nb_objs);
+
+ /* Feature on an arc cannot be called if feature arc is disabled */
+ fp_test_case_result_failed = 1;
+ fp_error_node = node->name;
+ return 0;
+}
+
+uint16_t
+arc1_feature1_fa_fn(struct rte_graph *graph, struct rte_node *node,
+ void **objs, uint16_t nb_objs)
+{
+ return common_process_fn(graph, node, objs, nb_objs,
+ MAX_INDEXES, 0, INTERMEDIATE_FEATURE);
+}
+
+static struct rte_node_register arc1_feature1 = {
+ .name = ARC1_FEATURE1,
+ .process = arc1_feature1_fn,
+ .nb_edges = 0,
+ .init = common_arc1_init,
+};
+RTE_NODE_REGISTER(arc1_feature1);
+
+static struct rte_graph_feature_register feat_arc1_feature1 = {
+ .feature_name = ARC1_FEATURE1,
+ .arc_name = TEST_ARC1_NAME,
+ .feature_process_fn = arc1_feature1_fa_fn,
+ .feature_node = &arc1_feature1,
+ .override_index_cb = override_arc2_index,
+ .notifier_cb = update_sp_counters,
+};
+RTE_GRAPH_FEATURE_REGISTER(feat_arc1_feature1);
+
+uint16_t
+arc1_feature2_fa_fn(struct rte_graph *graph, struct rte_node *node,
+ void **objs, uint16_t nb_objs)
+{
+ return common_process_fn(graph, node, objs, nb_objs,
+ MAX_INDEXES, 0, INTERMEDIATE_FEATURE);
+}
+
+static struct rte_node_register arc1_feature2 = {
+ .name = ARC1_FEATURE2,
+ .process = arc1_feature2_fa_fn,
+ .nb_edges = 0,
+ .init = common_arc1_init,
+};
+RTE_NODE_REGISTER(arc1_feature2);
+
+/* add arc1_feature2 later using rte_graph_feature_add()*/
+static struct rte_graph_feature_register feat_arc1_feature2 = {
+ .feature_name = ARC1_FEATURE2,
+ .arc_name = TEST_ARC1_NAME,
+ .feature_process_fn = arc1_feature2_fa_fn,
+ .feature_node = &arc1_feature2,
+ .runs_after = ARC1_FEATURE1,
+ .notifier_cb = update_sp_counters,
+};
+
+uint16_t
+arc2_feature1_fa_fn(struct rte_graph *graph, struct rte_node *node,
+ void **objs, uint16_t nb_objs)
+{
+ return common_process_fn(graph, node, objs, nb_objs,
+ OVERRIDE_MAX_INDEX, 1, INTERMEDIATE_FEATURE);
+}
+
+static struct rte_node_register arc2_feature1 = {
+ .name = ARC2_FEATURE1,
+ .process = arc2_feature1_fa_fn,
+ .nb_edges = 0,
+ .init = common_arc2_init,
+};
+RTE_NODE_REGISTER(arc2_feature1);
+
+static struct rte_graph_feature_register feat_arc2_feature1 = {
+ .feature_name = ARC2_FEATURE1,
+ .arc_name = TEST_ARC2_NAME,
+ .feature_process_fn = arc2_feature1_fa_fn,
+ .feature_node = &arc2_feature1,
+ .notifier_cb = update_sp_counters,
+};
+RTE_GRAPH_FEATURE_REGISTER(feat_arc2_feature1);
+
+uint16_t
+arc2_feature2_fa_fn(struct rte_graph *graph, struct rte_node *node,
+ void **objs, uint16_t nb_objs)
+{
+ return common_process_fn(graph, node, objs, nb_objs,
+ OVERRIDE_MAX_INDEX, 1, INTERMEDIATE_FEATURE);
+}
+
+static struct rte_node_register arc2_feature2 = {
+ .name = ARC2_FEATURE2,
+ .process = arc2_feature2_fa_fn,
+ .nb_edges = 0,
+ .init = common_arc2_init,
+};
+RTE_NODE_REGISTER(arc2_feature2);
+
+static struct rte_graph_feature_register feat_arc2_feature2 = {
+ .feature_name = ARC2_FEATURE2,
+ .arc_name = TEST_ARC2_NAME,
+ .feature_process_fn = arc2_feature2_fa_fn,
+ .feature_node = &arc2_feature2,
+ .runs_after = ARC2_FEATURE1,
+ .runs_before = ARC2_FEATURE3,
+ .override_index_cb = override_arc2_index,
+ .notifier_cb = update_sp_counters,
+};
+RTE_GRAPH_FEATURE_REGISTER(feat_arc2_feature2);
+
+uint16_t
+arc2_feature3_fa_fn(struct rte_graph *graph, struct rte_node *node,
+ void **objs, uint16_t nb_objs)
+{
+ return common_process_fn(graph, node, objs, nb_objs,
+ OVERRIDE_MAX_INDEX, 1, INTERMEDIATE_FEATURE);
+}
+
+static struct rte_node_register arc2_feature3 = {
+ .name = ARC2_FEATURE3,
+ .process = arc2_feature3_fa_fn,
+ .nb_edges = 0,
+ .init = common_arc2_init,
+};
+RTE_NODE_REGISTER(arc2_feature3);
+
+static struct rte_graph_feature_register feat_arc2_feature3 = {
+ .feature_name = ARC2_FEATURE3,
+ .arc_name = TEST_ARC2_NAME,
+ .feature_process_fn = arc2_feature3_fa_fn,
+ .feature_node = &arc2_feature3,
+ .runs_after = ARC2_FEATURE1,
+ .notifier_cb = update_sp_counters,
+};
+RTE_GRAPH_FEATURE_REGISTER(feat_arc2_feature3);
+
+static int
+create_graph(void)
+{
+ struct rte_graph_param gconf = {
+ .socket_id = SOCKET_ID_ANY,
+ .nb_node_patterns = RTE_DIM(node_names_feature_arc),
+ .node_patterns = node_names_feature_arc,
+ };
+
+ graph_id = rte_graph_create("worker0", &gconf);
+ if (graph_id == RTE_GRAPH_ID_INVALID) {
+ printf("Graph creation failed with error = %d\n", rte_errno);
+ return TEST_FAILED;
+ }
+
+ return TEST_SUCCESS;
+}
+
+static int
+destroy_graph(void)
+{
+ if (graph_id != RTE_GRAPH_ID_INVALID) {
+ rte_graph_destroy(graph_id);
+ graph_id = RTE_GRAPH_ID_INVALID;
+ }
+
+ return TEST_SUCCESS;
+}
+
+static int test_perf(uint64_t end_feature_counters)
+{
+ struct rte_graph *graph = NULL;
+ int i;
+
+ fp_test_case_result_failed = 0;
+ fp_error_node = NULL;
+ fp_end_feature_counters = 0;
+
+ if (create_graph() < 0) {
+ printf("Graph creation failed while walk\n");
+ return TEST_FAILED;
+ }
+ graph = rte_graph_lookup("worker0");
+ if (graph) {
+ for (i = 0; i < 10; i++)
+ rte_graph_walk(graph);
+ }
+ if (destroy_graph() < 0) {
+ printf("Graph destroy failed while walk\n");
+ return TEST_FAILED;
+ }
+ if (fp_test_case_result_failed) {
+ printf("Feature arc test failed for node %s\n", fp_error_node);
+ return TEST_FAILED;
+ }
+
+ if (sp_enable_counters &&
+ (sp_enable_cb_counters != sp_enable_counters)) {
+ printf("sp_enable_cb_counters mismatch %"PRIu64" !=
%"PRIu64"\n",
+ sp_enable_cb_counters, sp_enable_counters);
+ return TEST_FAILED;
+ }
+ if (sp_disable_counters &&
+ (sp_disable_cb_counters != sp_disable_counters)) {
+ printf("sp_disable_cb_counters mismatch %"PRIu64" !=
%"PRIu64"\n",
+ sp_disable_cb_counters, sp_disable_counters);
+ return TEST_FAILED;
+ }
+ if (fp_end_feature_counters != end_feature_counters) {
+ printf("end_bufs_counters mismatch %"PRIu64" != %"PRIu64"\n",
+ fp_end_feature_counters, end_feature_counters);
+ return TEST_FAILED;
+ }
+ sp_enable_counters = 0;
+ sp_enable_cb_counters = 0;
+ sp_disable_counters = 0;
+ sp_disable_cb_counters = 0;
+ return TEST_SUCCESS;
+}
+
+static int
+__test_create_feature_arc(rte_graph_feature_arc_t *arcs, uint16_t max_arcs)
+{
+ struct rte_graph_feature_arc_register reg;
+ struct rte_graph_feature_register feat;
+ rte_graph_feature_arc_t arc;
+ const char *sample_arc_name = "sample_arc";
+ char arc_name[256];
+ int n_arcs;
+
+ if (rte_graph_feature_arc_init(max_arcs) < 0) {
+ printf("Feature arc creation failed for arc: %u\n", max_arcs);
+ return TEST_FAILED;
+ }
+
+ feat.feature_name = DUMMY2_STATIC;
+ feat.feature_process_fn = dummy2_fn;
+ feat.feature_node = &dummy2;
+ feat.feature_node_id = dummy2.id;
+ feat.runs_after = NULL;
+ feat.runs_before = NULL;
+
+ reg.max_indexes = MAX_INDEXES;
+ reg.max_features = 3;
+ reg.start_node = &dummy1;
+ reg.start_node_feature_process_fn = dummy1_fn;
+ reg.end_feature = &feat;
+ for (n_arcs = 0; n_arcs < max_arcs; n_arcs++) {
+ snprintf(arc_name, sizeof(arc_name), "%s-%u", sample_arc_name,
n_arcs);
+ feat.arc_name = arc_name;
+ reg.arc_name = arc_name;
+ if (rte_graph_feature_arc_create(®, &arcs[n_arcs]) < 0) {
+ printf("%s: Test failed for creating arc at index
%u\n", arc_name, n_arcs);
+ return TEST_FAILED;
+ }
+ }
+
+ if (rte_graph_feature_arc_create(&arc2_output, NULL) == 0) {
+ printf("Failure: Feature arc %s should have already been
created\n",
+ arc2_output.arc_name);
+ return TEST_FAILED;
+ }
+ /* Verify feature arc created more than max_arcs must fail */
+ for (n_arcs = 0; n_arcs < max_arcs; n_arcs++) {
+ snprintf(arc_name, sizeof(arc_name), "%s-%u", sample_arc_name,
n_arcs);
+ arc = RTE_GRAPH_FEATURE_ARC_INITIALIZER;
+ if (rte_graph_feature_arc_lookup_by_name(arc_name, &arc) == 0) {
+ if (arc != arcs[n_arcs]) {
+ printf("%s: Feature arc lookup mismatch for arc
[%u, exp: %u]\n",
+ arc_name, arc, arcs[n_arcs]);
+ return TEST_FAILED;
+ }
+ dbg("Feature arc lookup %s succeeded\n", arc_name);
+ } else {
+ printf("Feature arc lookup %s failed after creation\n",
arc_name);
+ return TEST_FAILED;
+ }
+ }
+ return TEST_SUCCESS;
+}
+
+static int
+test_graph_feature_arc_create(void)
+{
+ int ret = 0;
+
+ ret = __test_create_feature_arc(arcs, MAX_FEATURE_ARCS);
+ if (ret) {
+ printf("Feature arc creation test failed for %u number of arc
create\n",
+ MAX_FEATURE_ARCS);
+ goto test_failed;
+ }
+ if (rte_graph_feature_arc_lookup_by_name(TEST_FAILED_ARC, NULL) == 0) {
+ printf("Feature arc %s should not have been created\n",
TEST_FAILED_ARC);
+ goto test_failed;
+ }
+
+ /* Cleanup to verify recreation */
+ rte_graph_feature_arc_cleanup();
+
+ dbg("Feature arc cleanup done\n");
+
+ return TEST_SUCCESS;
+
+test_failed:
+ return TEST_FAILED;
+}
+
+static int
+graph_feature_arc_setup(void)
+{
+ unsigned long i, j;
+
+ for (i = 0; i <= MAX_NODES; i++) {
+ for (j = 0; j < MBUF_NUM; j++)
+ mbuf_p[i][j] = &mbufs[i][j];
+ }
+
+ return TEST_SUCCESS;
+
+}
+static int
+test_graph_feature_arc_features_add(void)
+{
+ struct rte_graph_feature_arc *arc = NULL;
+ rte_graph_feature_t temp;
+
+ if (rte_graph_feature_arc_init(1) < 0) {
+ printf("Feature arc creation failed just for adding
features\n");
+ return TEST_FAILED;
+ }
+
+ /* see if duplicates fails */
+ if (rte_graph_feature_add(&feat_arc2_feature1) == 0) {
+ printf("%s: Feature add failed for adding feature %s\n",
+ feat_arc2_feature1.arc_name,
feat_arc2_feature1.feature_name);
+ goto test_failed;
+ }
+
+ /* Create new arc1 */
+ arc1_input.end_feature->feature_node_id =
arc1_input.end_feature->feature_node->id;
+ if (rte_graph_feature_arc_create(&arc1_input, &arcs[0]) < 0) {
+ printf("%s: Feature arc creation failed\n", TEST_ARC2_NAME);
+ goto test_failed;
+ }
+
+ /* Add features to arc1 */
+ feat_arc1_feature1.feature_node_id =
feat_arc1_feature1.feature_node->id;
+ if (rte_graph_feature_add(&feat_arc1_feature1) < 0) {
+ printf("%s: Feature add failed for adding feature %s\n",
+ feat_arc1_feature1.arc_name,
feat_arc1_feature1.feature_name);
+ goto test_failed;
+ }
+
+ feat_arc1_feature2.feature_node_id =
feat_arc1_feature2.feature_node->id;
+ if (rte_graph_feature_add(&feat_arc1_feature2) < 0) {
+ printf("%s: Feature add failed for adding feature %s\n",
+ feat_arc1_feature2.arc_name,
feat_arc1_feature2.feature_name);
+ }
+
+ if (rte_graph_feature_arc_lookup_by_name(TEST_ARC2_NAME, &arcs[1]) < 0)
{
+ printf("%s: Feature arc lookup failed while adding features\n",
+ TEST_ARC2_NAME);
+ goto test_failed;
+ }
+
+ arc = rte_graph_feature_arc_get(arcs[1]);
+ if (!arc) {
+ printf("%s: Feature arc ptr cannot be NULL\n",
+ TEST_ARC2_NAME);
+ goto test_failed;
+ }
+
+ /* Make sure number of indexes are overridden by feature*/
+ if (arc->max_indexes < OVERRIDE_MAX_INDEX) {
+ printf("%s: Feature arc max_indexes mismatch %u < %u\n",
+ TEST_ARC2_NAME, arc->max_indexes, OVERRIDE_MAX_INDEX);
+ goto test_failed;
+ }
+
+ /* arc1_feature1 must be first feature to arcs[0] */
+ if (!strstr(ARC1_FEATURE1,
+ rte_graph_feature_arc_feature_to_name(arcs[0],
+ feature_cast(0)))) {
+ printf("%s: %s is not the first feature instead %s\n",
+ TEST_ARC1_NAME, ARC1_FEATURE1,
+ rte_graph_feature_arc_feature_to_name(arcs[0],
feature_cast(0)));
+ goto test_failed;
+ }
+
+ /* arc1_feature2 must be second feature to arcs[0] */
+ if (!strstr(ARC1_FEATURE2,
+ rte_graph_feature_arc_feature_to_name(arcs[0],
+ feature_cast(1)))) {
+ printf("%s: %s is not the second feature instead %s\n",
+ TEST_ARC1_NAME, ARC1_FEATURE2,
+ rte_graph_feature_arc_feature_to_name(arcs[0],
feature_cast(1)));
+ goto test_failed;
+ }
+
+ /* Make sure INPUT_STATIC is the last feature in arcs[0] */
+ temp = rte_graph_feature_arc_num_features(arcs[0]);
+ if (!strstr(INPUT_STATIC,
+ rte_graph_feature_arc_feature_to_name(arcs[0],
+ temp -
feature_cast(1)))) {
+ printf("%s: %s is not the last feature instead %s\n",
+ TEST_ARC1_NAME, INPUT_STATIC,
+ rte_graph_feature_arc_feature_to_name(arcs[0],
+ temp -
feature_cast(1)));
+ goto test_failed;
+ }
+
+ /* arc2_feature1 must be first feature to arcs[1] */
+ if (!strstr(ARC2_FEATURE1,
+ rte_graph_feature_arc_feature_to_name(arcs[1],
+ feature_cast(0)))) {
+ printf("%s: %s is not the first feature instead %s\n",
+ TEST_ARC2_NAME, ARC2_FEATURE1,
+ rte_graph_feature_arc_feature_to_name(arcs[1],
feature_cast(0)));
+ goto test_failed;
+ }
+
+ /* arc2_feature2 must be second feature to arcs[1] */
+ if (!strstr(ARC2_FEATURE2,
+ rte_graph_feature_arc_feature_to_name(arcs[1],
+ feature_cast(1)))) {
+ printf("%s: %s is not the second feature instead %s\n",
+ TEST_ARC2_NAME, ARC2_FEATURE2,
+ rte_graph_feature_arc_feature_to_name(arcs[1],
feature_cast(1)));
+ goto test_failed;
+ }
+
+ /* arc2_feature3 must be third feature to arcs[1] */
+ if (!strstr(ARC2_FEATURE3,
+ rte_graph_feature_arc_feature_to_name(arcs[1],
+ feature_cast(2)))) {
+ printf("%s: %s is not the third feature instead %s\n",
+ TEST_ARC2_NAME, ARC2_FEATURE3,
+ rte_graph_feature_arc_feature_to_name(arcs[1],
feature_cast(2)));
+ goto test_failed;
+ }
+
+ /* Make sure PKT_FREE is the last feature in arcs[1] */
+ temp = rte_graph_feature_arc_num_features(arcs[1]);
+ if (!strstr(PKT_FREE_STATIC,
+ rte_graph_feature_arc_feature_to_name(arcs[1],
+ temp -
feature_cast(1)))) {
+ printf("%s: %s is not the last feature instead %s\n",
+ TEST_ARC2_NAME, PKT_FREE_STATIC,
+ rte_graph_feature_arc_feature_to_name(arcs[1],
+ temp -
feature_cast(1)));
+ goto test_failed;
+ }
+
+ /* Make sure feature is connected to end feature */
+ if (get_edge(&arc2_feature1, &node_pkt_free, NULL)) {
+ printf("%s: Edge not found between %s and %s\n",
+ TEST_ARC2_NAME, ARC2_FEATURE1, PKT_FREE_STATIC);
+ goto test_failed;
+ }
+
+ if (create_graph() < 0) {
+ printf("Graph creation failed while adding features\n");
+ goto test_failed;
+ }
+ if (destroy_graph() < 0) {
+ printf("Graph destroy failed while adding features\n");
+ goto test_failed;
+ }
+ return TEST_SUCCESS;
+test_failed:
+ rte_graph_feature_arc_cleanup();
+ return TEST_FAILED;
+}
+
+static int
+test_graph_feature_arc_feature_enable(void)
+{
+ uint32_t n_indexes, n_features, count = 0;
+ struct rte_node_register *parent, *child;
+ struct rte_graph_feature_arc *arc;
+ rte_graph_feature_data_t fdata;
+ char *feature_name = NULL;
+ rte_edge_t edge1, edge2;
+ uint16_t user_data;
+
+ if (rte_graph_feature_arc_lookup_by_name(TEST_ARC1_NAME, &arcs[0]) < 0)
{
+ printf("%s: Feature arc lookup failed while adding features\n",
+ TEST_ARC1_NAME);
+ return TEST_FAILED;
+ }
+
+ arc = rte_graph_feature_arc_get(arcs[0]);
+
+ if (rte_graph_feature_arc_is_any_feature_enabled(arc)) {
+ printf("%s: Feature arc should not have any feature enabled by
now\n",
+ TEST_ARC1_NAME);
+ return TEST_FAILED;
+ }
+
+ if (rte_graph_feature_arc_num_enabled_features(arcs[0])) {
+ printf("%s: Feature arc should not have any_feature() enabled
by now\n",
+ TEST_ARC1_NAME);
+ return TEST_FAILED;
+ }
+ /*
+ * On interface 0, enable feature 0,
+ * On interface 1, enable feature 1 and so on so forth
+ *
+ * later verify first feature on every interface index is unique
+ * and check [rte_edge, user_data] retrieved via fast path APIs
+ */
+ for (n_indexes = 0; n_indexes < arc->max_indexes; n_indexes++) {
+ n_features = n_indexes % RTE_DIM(arc1_feature_seq);
+ feature_name = rte_graph_feature_arc_feature_to_name(arcs[0],
n_features);
+ if (strncmp(feature_name, arc1_feature_seq[n_features],
+ RTE_GRAPH_NAMESIZE)) {
+ printf("%s: Feature(%u) seq mismatch [found: %s, exp:
%s]\n",
+ TEST_ARC1_NAME, n_features, feature_name,
+ arc1_feature_seq[n_features]);
+ return TEST_FAILED;
+ }
+ user_data = compute_unique_user_data(arc->start_node->name,
feature_name,
+ n_indexes);
+ /* negative test case. enable feature on invalid index */
+ if (!n_indexes && (rte_graph_feature_enable(arcs[0], 65535,
feature_name,
+ user_data, NULL) ==
0)) {
+ printf("%s: Feature %s should not be enabled on invalid
index\n",
+ TEST_ARC1_NAME, feature_name);
+ return TEST_FAILED;
+ }
+ if (rte_graph_feature_enable(arcs[0], n_indexes, feature_name,
+ user_data, NULL) < 0) {
+ printf("%s: Feature enable failed for %s on index %u\n",
+ TEST_ARC1_NAME, feature_name, n_indexes);
+ return TEST_FAILED;
+ }
+ sp_enable_counters++;
+ /* has any feature should be valid */
+ if (!rte_graph_feature_arc_is_any_feature_enabled(arc)) {
+ printf("%s: Feature arc should have any_feature enabled
by now\n",
+ TEST_ARC1_NAME);
+ return TEST_FAILED;
+ }
+ if ((count + 1) !=
rte_graph_feature_arc_num_enabled_features(arcs[0])) {
+ printf("%s: Number of enabled mismatches [found: %u,
exp: %u]\n",
+ TEST_ARC1_NAME,
+
rte_graph_feature_arc_num_enabled_features(arcs[0]),
+ count + 1);
+ return TEST_FAILED;
+ }
+ count++;
+ }
+ /* Negative test case */
+ user_data = compute_unique_user_data(arc->start_node->name,
ARC2_FEATURE1, 1);
+ if (!rte_graph_feature_enable(arcs[0], 1 /* index */, ARC2_FEATURE1,
user_data, NULL)) {
+ printf("%s: Invalid feature %s is enabled on index 1\n",
+ TEST_ARC1_NAME, ARC2_FEATURE1);
+ return TEST_FAILED;
+ }
+ /* Duplicate enable */
+ if (!rte_graph_feature_enable(arcs[0], 1 /* index */, ARC1_FEATURE2,
user_data, NULL)) {
+ printf("%s: Duplicate feature %s shouldn't be enabled again on
index 1\n",
+ TEST_ARC1_NAME, ARC1_FEATURE2);
+ return TEST_FAILED;
+ }
+ for (n_indexes = 0; n_indexes < arc->max_indexes; n_indexes++) {
+ if (!rte_graph_feature_data_first_feature_get(arc, n_indexes,
&fdata, &edge2)) {
+ printf("%s: FP first feature data get failed for index
%u\n",
+ TEST_ARC1_NAME, n_indexes);
+ return TEST_FAILED;
+ }
+ parent = arc->start_node;
+ if (0 == (n_indexes % RTE_DIM(arc1_feature_seq)))
+ child = &arc1_feature1;
+ else if (1 == (n_indexes % RTE_DIM(arc1_feature_seq)))
+ child = &arc1_feature2;
+ else
+ child = &node_input;
+
+ if (get_edge(parent, child, &edge1)) {
+ printf("%s: Edge not found between %s and %s\n",
+ TEST_ARC1_NAME, parent->name, child->name);
+ return TEST_FAILED;
+ }
+ if (edge1 != edge2) {
+ printf("%s: Edge mismatch for first feature on index %u
[%u, exp: %u]\n",
+ TEST_ARC1_NAME, n_indexes, edge2, edge1);
+ return TEST_FAILED;
+ }
+ if (compute_unique_user_data(parent->name, child->name,
n_indexes) !=
+ rte_graph_feature_data_app_cookie_get(arc, fdata)) {
+ printf("%s/idx: %u: Cookie mismatch for first feature
[%u, exp: %u]\n",
+ TEST_ARC1_NAME, n_indexes,
+ rte_graph_feature_data_app_cookie_get(arc,
fdata),
+ compute_unique_user_data(parent->name,
child->name, n_indexes));
+ return TEST_FAILED;
+ }
+ }
+ arc = rte_graph_feature_arc_get(arcs[1]);
+ for (n_indexes = 0; n_indexes < arc->max_indexes; n_indexes++) {
+ n_features = n_indexes % RTE_DIM(arc2_feature_seq);
+ feature_name = rte_graph_feature_arc_feature_to_name(arcs[1],
n_features);
+ if (strncmp(feature_name, arc2_feature_seq[n_features],
+ RTE_GRAPH_NAMESIZE)) {
+ printf("%s: Feature(%u) seq mismatch [found: %s, exp:
%s]\n",
+ arc->feature_arc_name, n_features, feature_name,
+ arc2_feature_seq[n_features]);
+ return TEST_FAILED;
+ }
+ user_data = compute_unique_user_data(arc->start_node->name,
feature_name,
+ n_indexes);
+ if (rte_graph_feature_enable(arcs[1], n_indexes, feature_name,
+ user_data, NULL) < 0) {
+ printf("%s: Feature enable failed for %s on index %u\n",
+ TEST_ARC2_NAME, feature_name, n_indexes);
+ return TEST_FAILED;
+ }
+ sp_enable_counters++;
+ }
+
+ return test_perf((2 * MBUF_NUM));
+}
+
+static int
+test_graph_feature_arc_feature_disable(void)
+{
+ struct rte_graph_feature_arc *arc;
+ uint32_t n_indexes, n_features;
+ char *feature_name = NULL;
+
+ arc = rte_graph_feature_arc_get(arcs[0]);
+ for (n_indexes = 0; n_indexes < arc->max_indexes; n_indexes++) {
+ n_features = n_indexes % RTE_DIM(arc1_feature_seq);
+ feature_name = rte_graph_feature_arc_feature_to_name(arcs[0],
n_features);
+ if (rte_graph_feature_disable(arcs[0], n_indexes, feature_name,
NULL)) {
+ printf("%s: feature disable failed for %s on index
%u\n",
+ arc->feature_arc_name, feature_name, n_indexes);
+ return TEST_FAILED;
+ }
+ sp_disable_counters++;
+ }
+
+ arc = rte_graph_feature_arc_get(arcs[1]);
+ for (n_indexes = 0; n_indexes < arc->max_indexes; n_indexes++) {
+ n_features = n_indexes % RTE_DIM(arc2_feature_seq);
+ feature_name = rte_graph_feature_arc_feature_to_name(arcs[1],
n_features);
+ if (rte_graph_feature_disable(arcs[1], n_indexes, feature_name,
NULL)) {
+ printf("%s: feature disable failed for %s on index
%u\n",
+ arc->feature_arc_name, feature_name, n_indexes);
+ return TEST_FAILED;
+ }
+ sp_disable_counters++;
+ }
+ /* All packets should exit */
+ return test_perf((2 * MBUF_NUM));
+}
+
+static int
+test_graph_feature_arc_destroy(void)
+{
+ rte_graph_feature_arc_t arc;
+
+ if (rte_graph_feature_arc_lookup_by_name(TEST_ARC1_NAME, &arc)) {
+ printf("Feature arc lookup failed for %s\n", TEST_ARC1_NAME);
+ return TEST_FAILED;
+ }
+
+ if (arc != arcs[0]) {
+ printf("Feature arc lookup mismatch for %s [%u, exp: %u]\n",
+ TEST_ARC1_NAME, arc, arcs[0]);
+ return TEST_FAILED;
+ }
+
+ if (rte_graph_feature_arc_destroy(arc)) {
+ printf("Feature arc destroy failed for %s\n", TEST_ARC1_NAME);
+ return TEST_FAILED;
+ }
+
+ if (rte_graph_feature_arc_lookup_by_name(TEST_ARC2_NAME, &arc)) {
+ printf("Feature arc lookup success after destroy for %s\n",
TEST_ARC2_NAME);
+ return TEST_FAILED;
+ }
+
+ if (arc != arcs[1]) {
+ printf("Feature arc lookup mismatch for %s [%u, exp: %u]\n",
+ TEST_ARC2_NAME, arc, arcs[1]);
+ return TEST_FAILED;
+ }
+ if (rte_graph_feature_arc_destroy(arc)) {
+ printf("Feature arc destroy failed for %s\n", TEST_ARC2_NAME);
+ return TEST_FAILED;
+ }
+ return TEST_SUCCESS;
+}
+
+static void
+graph_feature_arc_teardown(void)
+{
+ if (graph_id != RTE_GRAPH_ID_INVALID)
+ rte_graph_destroy(graph_id);
+
+ rte_graph_feature_arc_cleanup();
+}
+
+static struct unit_test_suite graph_feature_arc_testsuite = {
+ .suite_name = "Graph Feature arc library test suite",
+ .setup = graph_feature_arc_setup,
+ .teardown = graph_feature_arc_teardown,
+ .unit_test_cases = {
+ TEST_CASE(test_graph_feature_arc_create),
+ TEST_CASE(test_graph_feature_arc_features_add),
+ TEST_CASE(test_graph_feature_arc_feature_enable),
+ TEST_CASE(test_graph_feature_arc_feature_disable),
+ TEST_CASE(test_graph_feature_arc_destroy),
+ TEST_CASES_END(), /**< NULL terminate unit test array */
+ },
+};
+
+static int
+graph_feature_arc_autotest_fn(void)
+{
+ return unit_test_suite_runner(&graph_feature_arc_testsuite);
+}
+
+REGISTER_FAST_TEST(graph_feature_arc_autotest, true, true,
graph_feature_arc_autotest_fn);
+#endif /* !RTE_EXEC_ENV_WINDOWS */
--
2.43.0
