Re: [PATCH v12 7/7] test/graph_feature_arc: add functional tests

[Jerin Jacob <jerinjacobk@gmail.com>]

On Thu, Jun 5, 2025 at 11:22 PM Nitin Saxena <nsaxena@marvell.com> wrote:
>
> 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 <nsaxena@marvell.com>


Series Acked-by: Jerin Jacob <jerinj@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(&reg, &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
>