From patchwork Thu Oct 10 13:31:02 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Nitin Saxena X-Patchwork-Id: 145602 X-Patchwork-Delegate: thomas@monjalon.net Return-Path: X-Original-To: patchwork@inbox.dpdk.org Delivered-To: patchwork@inbox.dpdk.org Received: from mails.dpdk.org (mails.dpdk.org [217.70.189.124]) by inbox.dpdk.org (Postfix) with ESMTP id BCC4945B04; Thu, 10 Oct 2024 15:31:33 +0200 (CEST) Received: from mails.dpdk.org (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id 338454060B; Thu, 10 Oct 2024 15:31:30 +0200 (CEST) Received: from mx0b-0016f401.pphosted.com (mx0b-0016f401.pphosted.com [67.231.156.173]) by mails.dpdk.org (Postfix) with ESMTP id 2063B402A3 for ; Thu, 10 Oct 2024 15:31:27 +0200 (CEST) Received: from pps.filterd (m0431383.ppops.net [127.0.0.1]) by mx0b-0016f401.pphosted.com (8.18.1.2/8.18.1.2) with ESMTP id 49A710of008428; Thu, 10 Oct 2024 06:31:20 -0700 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=marvell.com; h= cc:content-transfer-encoding:content-type:date:from:in-reply-to :message-id:mime-version:references:subject:to; s=pfpt0220; bh=0 YL7xhgXoitkex7w7dSwbmtEb61PZtdp3HSHyhvLibI=; b=OR1t9Gkb9SqvdAYdy VY2wxdNDt6x0sc36pHvFt4ZtGl8LGAhx/AZ6SJhPJ82RsTeVDvm73Ue86TiNArWQ R7nEyIR/9wiwchH6nXKiF09qTtI7P7S3aeLIVs2QY00V2wGxlUKtpyIMcOsi+iNe fL0WznBh6VkqV324S/n0SIug/MLNdIPaGqun6uXpEMBc9VNhn2YzZKoYwZBXcy5a zpc+1bNjPk90bkozb5pDR0Y7TAFQ7lkPzeDwCaohp/fJg4pBgfSlUbLcCpaHfGFs z3NrF412RweISFlle7Fqdpd1cX+AKpHoPNQdM9saXyvaj2johg5EWDN1ZL/BPRcd KEFQA== Received: from dc5-exch05.marvell.com ([199.233.59.128]) by mx0b-0016f401.pphosted.com (PPS) with ESMTPS id 426a5n0pah-2 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Thu, 10 Oct 2024 06:31:19 -0700 (PDT) Received: from DC5-EXCH05.marvell.com (10.69.176.209) by DC5-EXCH05.marvell.com (10.69.176.209) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.2.1544.4; Thu, 10 Oct 2024 06:31:17 -0700 Received: from maili.marvell.com (10.69.176.80) by DC5-EXCH05.marvell.com (10.69.176.209) with Microsoft SMTP Server id 15.2.1544.4 via Frontend Transport; Thu, 10 Oct 2024 06:31:17 -0700 Received: from cavium-PowerEdge-R640.. (unknown [10.28.36.207]) by maili.marvell.com (Postfix) with ESMTP id 33AA03F7051; Thu, 10 Oct 2024 06:31:14 -0700 (PDT) From: Nitin Saxena To: Jerin Jacob , Kiran Kumar K , Nithin Dabilpuram , Zhirun Yan , Robin Jarry , Christophe Fontaine CC: , Nitin Saxena Subject: [PATCH v4 1/5] graph: add feature arc support Date: Thu, 10 Oct 2024 19:01:02 +0530 Message-ID: <20241010133111.2764712-2-nsaxena@marvell.com> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20241010133111.2764712-1-nsaxena@marvell.com> References: <20241009133009.1152321-1-nsaxena@marvell.com> <20241010133111.2764712-1-nsaxena@marvell.com> MIME-Version: 1.0 X-Proofpoint-GUID: ynv4MviyqDfDmQ62zIo00G8J5niuUqvw X-Proofpoint-ORIG-GUID: ynv4MviyqDfDmQ62zIo00G8J5niuUqvw X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.293,Aquarius:18.0.687,Hydra:6.0.235,FMLib:17.0.607.475 definitions=2020-10-13_15,2020-10-13_02,2020-04-07_01 X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org add feature arc to allow dynamic steering of packets across graph nodes based on protocol features enabled on incoming or outgoing interface Signed-off-by: Nitin Saxena --- doc/guides/rel_notes/release_24_11.rst | 10 + lib/graph/graph_feature_arc.c | 1236 ++++++++++++++++++++++ lib/graph/meson.build | 2 + lib/graph/rte_graph_feature_arc.h | 431 ++++++++ lib/graph/rte_graph_feature_arc_worker.h | 679 ++++++++++++ lib/graph/version.map | 20 + 6 files changed, 2378 insertions(+) create mode 100644 lib/graph/graph_feature_arc.c create mode 100644 lib/graph/rte_graph_feature_arc.h create mode 100644 lib/graph/rte_graph_feature_arc_worker.h diff --git a/doc/guides/rel_notes/release_24_11.rst b/doc/guides/rel_notes/release_24_11.rst index 2f78f2d125..bd5589b01c 100644 --- a/doc/guides/rel_notes/release_24_11.rst +++ b/doc/guides/rel_notes/release_24_11.rst @@ -82,6 +82,16 @@ New Features The new statistics are useful for debugging and profiling. +* **Added feature arc abstraction in graph library.** + + Feature arc abstraction helps ``rte_graph`` based applications to steer + packets across different node path(s) based on the features (or protocols) + enabled on interfaces. Different feature node paths can be enabled/disabled + at runtime on some or on all interfaces. This abstraction also help + applications to hook their ``custom nodes`` in standard DPDK node paths + without any code changes in the later. + + * Added ``ip4-output`` feature arc processing in ``ip4_rewrite`` node. Removed Items ------------- diff --git a/lib/graph/graph_feature_arc.c b/lib/graph/graph_feature_arc.c new file mode 100644 index 0000000000..0f8633c317 --- /dev/null +++ b/lib/graph/graph_feature_arc.c @@ -0,0 +1,1236 @@ +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright(C) 2024 Marvell International Ltd. + */ + +#include "graph_private.h" +#include +#include + +#define ARC_PASSIVE_LIST(list) (list ^ 0x1) + +#define rte_graph_uint_cast(x) ((unsigned int)x) +#define feat_dbg graph_dbg + +static rte_graph_feature_arc_main_t *__rte_graph_feature_arc_main; + +/* Make sure fast path cache line is compact */ +_Static_assert((offsetof(struct rte_graph_feature_arc, slow_path_variables) + - offsetof(struct rte_graph_feature_arc, fast_path_variables)) + <= RTE_CACHE_LINE_SIZE, + "Fast path feature arc variables exceed cache line size"); + +#define connect_graph_nodes(node1, node2, edge, arc_name) \ + __connect_graph_nodes(node1, node2, edge, arc_name, __LINE__) + +#define FEAT_COND_ERR(cond, fmt, ...) \ + do { \ + if (cond) \ + graph_err(fmt, ##__VA_ARGS__); \ + } while (0) + +/* + * lookup feature name and get control path node_list as well as feature index + * at which it is inserted + */ +static int +feature_lookup(struct rte_graph_feature_arc *arc, const char *feat_name, + struct rte_graph_feature_node_list **ffinfo, uint32_t *slot) +{ + struct rte_graph_feature_node_list *finfo = NULL; + const char *name; + uint32_t fi = 0; + + if (!feat_name) + return -1; + + if (slot) + *slot = UINT32_MAX; + + STAILQ_FOREACH(finfo, &arc->all_features, next_feature) { + RTE_VERIFY(finfo->feature_arc == arc); + name = rte_node_id_to_name(finfo->feature_node->id); + if (!strncmp(name, feat_name, strlen(name))) { + if (ffinfo) + *ffinfo = finfo; + if (slot) + *slot = fi; + return 0; + } + fi++; + } + return -1; +} + +/* Lookup used only during rte_graph_feature_add() */ +static int +feature_add_lookup(struct rte_graph_feature_arc *arc, const char *feat_name, + struct rte_graph_feature_node_list **ffinfo, uint32_t *slot) +{ + struct rte_graph_feature_node_list *finfo = NULL; + const char *name; + uint32_t fi = 0; + + if (!feat_name) + return -1; + + if (slot) + *slot = 0; + + STAILQ_FOREACH(finfo, &arc->all_features, next_feature) { + RTE_VERIFY(finfo->feature_arc == arc); + name = rte_node_id_to_name(finfo->feature_node->id); + if (!strncmp(name, feat_name, strlen(name))) { + if (ffinfo) + *ffinfo = finfo; + if (slot) + *slot = fi; + return 0; + } + /* Update slot where new feature can be added */ + if (slot) + *slot = fi; + fi++; + } + + return -1; +} + +/* Get control path node info from provided input feature_index */ +static int +feature_arc_node_info_lookup(struct rte_graph_feature_arc *arc, uint32_t feature_index, + struct rte_graph_feature_node_list **ppfinfo, + const int do_sanity_check) +{ + struct rte_graph_feature_node_list *finfo = NULL; + uint32_t index = 0; + + if (!ppfinfo) + return -1; + + *ppfinfo = NULL; + STAILQ_FOREACH(finfo, &arc->all_features, next_feature) { + /* Check sanity */ + if (do_sanity_check) + if (finfo->node_index != index) + RTE_VERIFY(0); + if (index == feature_index) { + *ppfinfo = finfo; + return 0; + } + index++; + } + return -1; +} + +/* prepare feature arc after addition of all features */ +static void +prepare_feature_arc_before_first_enable(struct rte_graph_feature_arc *arc) +{ + struct rte_graph_feature_node_list *finfo = NULL; + uint32_t index = 0; + + rte_atomic_store_explicit(&arc->active_feature_list, 0, + rte_memory_order_relaxed); + + STAILQ_FOREACH(finfo, &arc->all_features, next_feature) { + finfo->node_index = index; + feat_dbg("\t%s prepare: %s added to list at index: %u", arc->feature_arc_name, + finfo->feature_node->name, index); + index++; + } +} + +/* feature arc lookup in array */ +static int +feature_arc_lookup(rte_graph_feature_arc_t _arc) +{ + struct rte_graph_feature_arc *arc = rte_graph_feature_arc_get(_arc); + rte_graph_feature_arc_main_t *dm = __rte_graph_feature_arc_main; + uint32_t iter; + + if (!__rte_graph_feature_arc_main) + return -1; + + for (iter = 0; iter < dm->max_feature_arcs; iter++) { + if (dm->feature_arcs[iter] == RTE_GRAPH_FEATURE_ARC_INITIALIZER) + continue; + + if (arc == (rte_graph_feature_arc_get(dm->feature_arcs[iter]))) + return 0; + } + return -1; +} + +/* Check valid values for known fields in arc to make sure arc is sane */ +static int check_feature_arc_sanity(rte_graph_feature_arc_t _arc, int iter) +{ +#ifdef FEATURE_ARC_DEBUG + struct rte_graph_feature_arc *arc = rte_graph_feature_arc_get(_arc); + + RTE_VERIFY(arc->feature_arc_main == __rte_graph_feature_arc_main); + RTE_VERIFY(arc->feature_arc_index == iter); + + RTE_VERIFY(arc->feature_list[0]->indexed_by_features = arc->features[0]); + RTE_VERIFY(arc->feature_list[1]->indexed_by_features = arc->features[1]); + + RTE_VERIFY(rte_atomic_load_explicit(&arc->active_feature_list, + rte_memory_order_relaxed) < 2); +#else + RTE_SET_USED(_arc); + RTE_SET_USED(iter); +#endif + return 0; +} + +/* Perform sanity on all arc if any corruption occurred */ +static int do_sanity_all_arcs(void) +{ + rte_graph_feature_arc_main_t *dm = __rte_graph_feature_arc_main; + uint32_t iter; + + if (!dm) + return -1; + + for (iter = 0; iter < dm->max_feature_arcs; iter++) { + if (dm->feature_arcs[iter] == RTE_GRAPH_FEATURE_ARC_INITIALIZER) + continue; + + if (check_feature_arc_sanity(dm->feature_arcs[iter], iter)) + return -1; + } + return 0; +} + +/* get existing edge from parent_node -> child_node */ +static int +get_existing_edge(const char *arc_name, struct rte_node_register *parent_node, + struct rte_node_register *child_node, rte_edge_t *_edge) +{ + char **next_edges = NULL; + uint32_t i, count = 0; + + RTE_SET_USED(arc_name); + + 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; +} + +/* create or retrieve already existing edge from parent_node -> child_node */ +static int +__connect_graph_nodes(struct rte_node_register *parent_node, struct rte_node_register *child_node, + rte_edge_t *_edge, char *arc_name, int lineno) +{ + const char *next_node = NULL; + rte_edge_t edge; + + if (!get_existing_edge(arc_name, parent_node, child_node, &edge)) { + feat_dbg("\t%s/%d: %s[%u]: \"%s\", edge reused", arc_name, lineno, + parent_node->name, edge, child_node->name); + + if (_edge) + *_edge = edge; + + return 0; + } + + /* Node to be added */ + next_node = child_node->name; + + edge = rte_node_edge_update(parent_node->id, RTE_EDGE_ID_INVALID, &next_node, 1); + + if (edge == RTE_EDGE_ID_INVALID) { + graph_err("edge invalid"); + return -1; + } + edge = rte_node_edge_count(parent_node->id) - 1; + + feat_dbg("\t%s/%d: %s[%u]: \"%s\", new edge added", arc_name, lineno, parent_node->name, + edge, child_node->name); + + if (_edge) + *_edge = edge; + + return 0; +} + +/* feature arc initialization */ +static int +feature_arc_main_init(rte_graph_feature_arc_main_t **pfl, uint32_t max_feature_arcs) +{ + rte_graph_feature_arc_main_t *pm = NULL; + uint32_t i; + size_t sz; + + if (!pfl) + return -1; + + sz = sizeof(rte_graph_feature_arc_main_t) + + (sizeof(pm->feature_arcs[0]) * max_feature_arcs); + + pm = rte_malloc("rte_graph_feature_arc_main", sz, 0); + if (!pm) + return -1; + + memset(pm, 0, sz); + + for (i = 0; i < max_feature_arcs; i++) + pm->feature_arcs[i] = RTE_GRAPH_FEATURE_ARC_INITIALIZER; + + pm->max_feature_arcs = max_feature_arcs; + + *pfl = pm; + + return 0; +} + +/* feature arc initialization, public API */ +int +rte_graph_feature_arc_init(int max_feature_arcs) +{ + if (!max_feature_arcs) + return -1; + + if (__rte_graph_feature_arc_main) + return -1; + + return feature_arc_main_init(&__rte_graph_feature_arc_main, max_feature_arcs); +} + +/* reset feature list before switching to passive list */ +static void +feature_arc_list_reset(struct rte_graph_feature_arc *arc, uint32_t list_index) +{ + rte_graph_feature_data_t *fdata = NULL; + rte_graph_feature_list_t *list = NULL; + struct rte_graph_feature *feat = NULL; + uint32_t i, j; + + list = arc->feature_list[list_index]; + feat = arc->features[list_index]; + + /*Initialize variables*/ + memset(feat, 0, arc->feature_size * arc->max_features); + memset(list, 0, arc->feature_list_size); + + /* Initialize feature and feature_data */ + for (i = 0; i < arc->max_features; i++) { + feat = __rte_graph_feature_get(arc, i, list_index); + feat->this_feature_index = i; + + for (j = 0; j < arc->max_indexes; j++) { + fdata = rte_graph_feature_data_get(arc, feat, j); + fdata->next_enabled_feature = RTE_GRAPH_FEATURE_INVALID; + fdata->next_edge = UINT16_MAX; + fdata->user_data = UINT32_MAX; + } + } + + for (i = 0; i < arc->max_indexes; i++) + list->first_enabled_feature_by_index[i] = RTE_GRAPH_FEATURE_INVALID; +} + +static int +feature_arc_list_init(struct rte_graph_feature_arc *arc, const char *flist_name, + rte_graph_feature_list_t **pplist, + struct rte_graph_feature **ppfeature, uint32_t list_index) +{ + char fname[2 * RTE_GRAPH_FEATURE_ARC_NAMELEN]; + size_t list_size, feat_size, fdata_size; + rte_graph_feature_list_t *list = NULL; + struct rte_graph_feature *feat = NULL; + + list_size = sizeof(struct rte_graph_feature_list) + + (sizeof(list->first_enabled_feature_by_index[0]) * arc->max_indexes); + + list_size = RTE_ALIGN_CEIL(list_size, RTE_CACHE_LINE_SIZE); + + list = rte_malloc(flist_name, list_size, RTE_CACHE_LINE_SIZE); + if (!list) + return -ENOMEM; + + memset(list, 0, list_size); + fdata_size = arc->max_indexes * sizeof(rte_graph_feature_data_t); + + /* Let one feature and its associated data per index capture complete + * cache lines + */ + feat_size = RTE_ALIGN_CEIL(sizeof(struct rte_graph_feature) + fdata_size, + RTE_CACHE_LINE_SIZE); + + snprintf(fname, sizeof(fname), "%s-%s", arc->feature_arc_name, "feat"); + + feat = rte_malloc(fname, feat_size * arc->max_features, RTE_CACHE_LINE_SIZE); + if (!feat) { + rte_free(list); + return -ENOMEM; + } + arc->feature_size = feat_size; + arc->feature_data_size = fdata_size; + arc->feature_list_size = list_size; + + /* Initialize list */ + list->indexed_by_features = feat; + *pplist = list; + *ppfeature = feat; + + feature_arc_list_reset(arc, list_index); + + return 0; +} + +/* free resources allocated in feature_arc_list_init() */ +static void +feature_arc_list_destroy(struct rte_graph_feature_arc *arc, int list_index) +{ + rte_graph_feature_list_t *list = NULL; + + list = arc->feature_list[list_index]; + + rte_free(list->indexed_by_features); + + arc->features[list_index] = NULL; + + rte_free(list); + + arc->feature_list[list_index] = NULL; +} + +int +rte_graph_feature_arc_create(const char *feature_arc_name, int max_features, int max_indexes, + struct rte_node_register *start_node, rte_graph_feature_arc_t *_arc) +{ + char name[2 * RTE_GRAPH_FEATURE_ARC_NAMELEN]; + struct rte_graph_feature_data *gfd = NULL; + rte_graph_feature_arc_main_t *dfm = NULL; + struct rte_graph_feature_arc *arc = NULL; + struct rte_graph_feature *df = NULL; + uint32_t iter, j, arc_index; + size_t sz; + + if (!_arc) + SET_ERR_JMP(EINVAL, err, "%s: Invalid _arc", feature_arc_name); + + if (max_features < 2) + SET_ERR_JMP(EINVAL, err, "%s: max_features must be greater than 1", + feature_arc_name); + + if (!start_node) + SET_ERR_JMP(EINVAL, err, "%s: start_node cannot be NULL", + feature_arc_name); + + if (!feature_arc_name) + SET_ERR_JMP(EINVAL, err, "%s: feature_arc name cannot be NULL", + feature_arc_name); + + if (max_features > RTE_GRAPH_FEATURE_MAX_PER_ARC) + SET_ERR_JMP(EAGAIN, err, "%s: number of features cannot be greater than 64", + feature_arc_name); + + /* + * Application hasn't called rte_graph_feature_arc_init(). Initialize with + * default values + */ + if (!__rte_graph_feature_arc_main) { + if (rte_graph_feature_arc_init((int)RTE_GRAPH_FEATURE_ARC_MAX) < 0) { + graph_err("rte_graph_feature_arc_init() failed"); + return -1; + } + } + + /* If name is not unique */ + if (!rte_graph_feature_arc_lookup_by_name(feature_arc_name, NULL)) + SET_ERR_JMP(EINVAL, err, "%s: feature arc name already exists", + feature_arc_name); + + dfm = __rte_graph_feature_arc_main; + + /* threshold check */ + if (dfm->num_feature_arcs > (dfm->max_feature_arcs - 1)) + SET_ERR_JMP(EAGAIN, err, "%s: max number (%u) of feature arcs reached", + feature_arc_name, dfm->max_feature_arcs); + + /* Find the free slot for feature arc */ + for (iter = 0; iter < dfm->max_feature_arcs; iter++) { + if (dfm->feature_arcs[iter] == RTE_GRAPH_FEATURE_ARC_INITIALIZER) + break; + } + arc_index = iter; + + if (arc_index >= dfm->max_feature_arcs) { + graph_err("No free slot found for num_feature_arc"); + return -1; + } + + /* This should not happen */ + RTE_VERIFY(dfm->feature_arcs[arc_index] == RTE_GRAPH_FEATURE_ARC_INITIALIZER); + + /* size of feature arc + feature_bit_mask_by_index */ + sz = RTE_ALIGN_CEIL(sizeof(*arc) + (sizeof(uint64_t) * max_indexes), RTE_CACHE_LINE_SIZE); + + arc = rte_malloc(feature_arc_name, sz, RTE_CACHE_LINE_SIZE); + + if (!arc) { + graph_err("malloc failed for feature_arc_create()"); + return -1; + } + + memset(arc, 0, sz); + + /* Initialize rte_graph port group fixed variables */ + STAILQ_INIT(&arc->all_features); + strncpy(arc->feature_arc_name, feature_arc_name, RTE_GRAPH_FEATURE_ARC_NAMELEN - 1); + arc->feature_arc_main = (void *)dfm; + arc->start_node = start_node; + arc->max_features = max_features; + arc->max_indexes = max_indexes; + arc->feature_arc_index = arc_index; + + snprintf(name, sizeof(name), "%s-%s", feature_arc_name, "flist0"); + + if (feature_arc_list_init(arc, name, &arc->feature_list[0], &arc->features[0], 0) < 0) { + rte_free(arc); + graph_err("feature_arc_list_init(0) failed"); + return -1; + } + snprintf(name, sizeof(name), "%s-%s", feature_arc_name, "flist1"); + + if (feature_arc_list_init(arc, name, &arc->feature_list[1], &arc->features[1], 1) < 0) { + feature_arc_list_destroy(arc, 0); + rte_free(arc); + graph_err("feature_arc_list_init(1) failed"); + return -1; + } + + for (iter = 0; iter < arc->max_features; iter++) { + df = rte_graph_feature_get(arc, iter); + for (j = 0; j < arc->max_indexes; j++) { + gfd = rte_graph_feature_data_get(arc, df, j); + gfd->next_enabled_feature = RTE_GRAPH_FEATURE_INVALID; + } + } + dfm->feature_arcs[arc->feature_arc_index] = (rte_graph_feature_arc_t)arc; + dfm->num_feature_arcs++; + + if (_arc) + *_arc = (rte_graph_feature_arc_t)arc; + + do_sanity_all_arcs(); + + feat_dbg("Feature arc %s[%p] created with max_features: %u and indexes: %u", + feature_arc_name, (void *)arc, max_features, max_indexes); + return 0; + +err: + return -rte_errno; +} + +int +rte_graph_feature_add(rte_graph_feature_arc_t _arc, struct rte_node_register *feature_node, + const char *_runs_after, const char *runs_before) +{ + struct rte_graph_feature_node_list *after_finfo = NULL, *before_finfo = NULL; + struct rte_graph_feature_arc *arc = rte_graph_feature_arc_get(_arc); + struct rte_graph_feature_node_list *temp = NULL, *finfo = NULL; + char feature_name[3*RTE_GRAPH_FEATURE_ARC_NAMELEN]; + const char *runs_after = NULL; + uint32_t num_feature = 0; + uint32_t slot, add_flag; + rte_edge_t edge = -1; + + /* sanity */ + if (arc->feature_arc_main != __rte_graph_feature_arc_main) { + graph_err("feature arc not created: 0x%016" PRIx64, (uint64_t)_arc); + return -1; + } + + if (feature_arc_lookup(_arc)) { + graph_err("invalid feature arc: 0x%016" PRIx64, (uint64_t)_arc); + return -1; + } + + if (arc->runtime_enabled_features) { + graph_err("adding features after enabling any one of them is not supported"); + return -1; + } + + if ((_runs_after != NULL) && (runs_before != NULL) && + (_runs_after == runs_before)) { + graph_err("runs_after and runs_before are same '%s:%s]", _runs_after, + runs_before); + return -1; + } + + if (!feature_node) { + graph_err("feature_node: %p invalid", feature_node); + return -1; + } + + arc = rte_graph_feature_arc_get(_arc); + + if (feature_node->id == RTE_NODE_ID_INVALID) { + graph_err("Invalid node: %s", feature_node->name); + return -1; + } + + if (!feature_add_lookup(arc, feature_node->name, &finfo, &slot)) { + graph_err("%s feature already added", feature_node->name); + return -1; + } + + if (slot >= arc->max_features) { + graph_err("%s: Max features %u added to feature arc", + arc->feature_arc_name, slot); + return -1; + } + + if (strstr(feature_node->name, arc->start_node->name)) { + graph_err("Feature %s cannot point to itself: %s", feature_node->name, + arc->start_node->name); + return -1; + } + + feat_dbg("%s: adding feature node: %s at feature index: %u", arc->feature_arc_name, + feature_node->name, slot); + + if (connect_graph_nodes(arc->start_node, feature_node, &edge, arc->feature_arc_name)) { + graph_err("unable to connect %s -> %s", arc->start_node->name, feature_node->name); + return -1; + } + + snprintf(feature_name, sizeof(feature_name), "%s-%s-finfo", + arc->feature_arc_name, feature_node->name); + + finfo = rte_malloc(feature_name, sizeof(*finfo), 0); + if (!finfo) { + graph_err("%s/%s: rte_malloc failed", arc->feature_arc_name, feature_node->name); + return -1; + } + + memset(finfo, 0, sizeof(*finfo)); + + finfo->feature_arc = (void *)arc; + finfo->feature_node = feature_node; + finfo->edge_to_this_feature = edge; + arc->runtime_enabled_features = 0; + + /* + * if no constraints given and provided feature is not the first feature, + * explicitly set "runs_after" as last_feature. Handles the case: + * + * add(f1, NULL, NULL); + * add(f2, NULL, NULL); + */ + num_feature = rte_graph_feature_arc_num_features(_arc); + if (!_runs_after && !runs_before && num_feature) + runs_after = rte_graph_feature_arc_feature_to_name(_arc, num_feature - 1); + else + runs_after = _runs_after; + + /* Check for before and after constraints */ + if (runs_before) { + /* runs_before sanity */ + if (feature_lookup(arc, runs_before, &before_finfo, NULL)) + SET_ERR_JMP(EINVAL, finfo_free, + "Invalid before feature name: %s", runs_before); + + if (!before_finfo) + SET_ERR_JMP(EINVAL, finfo_free, + "runs_before %s does not exist", runs_before); + + /* + * Starting from 0 to runs_before, continue connecting edges + */ + add_flag = 1; + STAILQ_FOREACH(temp, &arc->all_features, next_feature) { + if (!add_flag) + /* Nodes after seeing "runs_before", finfo connects to temp*/ + connect_graph_nodes(finfo->feature_node, temp->feature_node, + NULL, arc->feature_arc_name); + /* + * As soon as we see runs_before. stop adding edges + */ + if (!strncmp(temp->feature_node->name, runs_before, + RTE_GRAPH_NAMESIZE)) { + if (!connect_graph_nodes(finfo->feature_node, temp->feature_node, + &edge, arc->feature_arc_name)) + add_flag = 0; + } + + if (add_flag) + /* Nodes before seeing "run_before" are connected to finfo */ + connect_graph_nodes(temp->feature_node, finfo->feature_node, NULL, + arc->feature_arc_name); + } + } + + if (runs_after) { + if (feature_lookup(arc, runs_after, &after_finfo, NULL)) + SET_ERR_JMP(EINVAL, finfo_free, + "Invalid after feature_name %s", runs_after); + + if (!after_finfo) + SET_ERR_JMP(EINVAL, finfo_free, + "runs_after %s does not exist", runs_after); + + /* Starting from runs_after to end continue connecting edges */ + add_flag = 0; + STAILQ_FOREACH(temp, &arc->all_features, next_feature) { + if (add_flag) + /* We have already seen runs_after now */ + /* Add all features as next node to current feature*/ + connect_graph_nodes(finfo->feature_node, temp->feature_node, NULL, + arc->feature_arc_name); + else + /* Connect initial nodes to newly added node*/ + connect_graph_nodes(temp->feature_node, finfo->feature_node, NULL, + arc->feature_arc_name); + + /* as soon as we see runs_after. start adding edges + * from next iteration + */ + if (!strncmp(temp->feature_node->name, runs_after, RTE_GRAPH_NAMESIZE)) + add_flag = 1; + } + + /* add feature next to runs_after */ + STAILQ_INSERT_AFTER(&arc->all_features, after_finfo, finfo, next_feature); + } else { + if (before_finfo) { + /* add finfo before "before_finfo" element in the list */ + after_finfo = NULL; + STAILQ_FOREACH(temp, &arc->all_features, next_feature) { + if (before_finfo == temp) { + if (after_finfo) + STAILQ_INSERT_AFTER(&arc->all_features, after_finfo, + finfo, next_feature); + else + STAILQ_INSERT_HEAD(&arc->all_features, finfo, + next_feature); + + return 0; + } + after_finfo = temp; + } + } else { + /* Very first feature just needs to be added to list */ + STAILQ_INSERT_TAIL(&arc->all_features, finfo, next_feature); + } + } + + return 0; + +finfo_free: + rte_free(finfo); + + return -1; +} + +int +rte_graph_feature_lookup(rte_graph_feature_arc_t _arc, const char *feature_name, + rte_graph_feature_t *feat) +{ + struct rte_graph_feature_arc *arc = rte_graph_feature_arc_get(_arc); + struct rte_graph_feature_node_list *finfo = NULL; + uint32_t slot; + + if (!feature_lookup(arc, feature_name, &finfo, &slot)) { + *feat = (rte_graph_feature_t) slot; + return 0; + } + + return -1; +} + +int +rte_graph_feature_validate(rte_graph_feature_arc_t _arc, uint32_t index, const char *feature_name, + int is_enable_disable, bool emit_logs) +{ + struct rte_graph_feature_arc *arc = rte_graph_feature_arc_get(_arc); + struct rte_graph_feature_node_list *finfo = NULL; + rte_graph_feature_rt_list_t active_list; + struct rte_graph_feature *gf = NULL; + uint32_t slot; + + /* validate _arc */ + if (arc->feature_arc_main != __rte_graph_feature_arc_main) { + FEAT_COND_ERR(emit_logs, "invalid feature arc: 0x%016" PRIx64, (uint64_t)_arc); + return -EINVAL; + } + + /* validate index */ + if (index >= arc->max_indexes) { + FEAT_COND_ERR(emit_logs, "%s: Invalid provided index: %u >= %u configured", + arc->feature_arc_name, index, arc->max_indexes); + return -1; + } + + /* validate feature_name is already added or not */ + if (feature_lookup(arc, feature_name, &finfo, &slot)) { + FEAT_COND_ERR(emit_logs, "%s: No feature %s added", + arc->feature_arc_name, feature_name); + return -EINVAL; + } + + if (!finfo) { + FEAT_COND_ERR(emit_logs, "%s: No feature: %s found", + arc->feature_arc_name, feature_name); + return -EINVAL; + } + + /* slot should be in valid range */ + if (slot >= arc->max_features) { + FEAT_COND_ERR(emit_logs, "%s/%s: Invalid free slot %u(max=%u) for feature", + arc->feature_arc_name, feature_name, slot, arc->max_features); + return -EINVAL; + } + + /* slot should be in range of 0 - 63 */ + if (slot > (RTE_GRAPH_FEATURE_MAX_PER_ARC - 1)) { + FEAT_COND_ERR(emit_logs, "%s/%s: Invalid slot: %u", arc->feature_arc_name, + feature_name, slot); + return -EINVAL; + } + + if (finfo->node_index != slot) { + FEAT_COND_ERR(emit_logs, + "%s/%s: lookup slot mismatch for finfo idx: %u and lookup slot: %u", + arc->feature_arc_name, feature_name, finfo->node_index, slot); + return -1; + } + + active_list = rte_atomic_load_explicit(&arc->active_feature_list, + rte_memory_order_relaxed); + + /* Get feature from active list */ + gf = __rte_graph_feature_get(arc, slot, ARC_PASSIVE_LIST(active_list)); + if (gf->this_feature_index != slot) { + FEAT_COND_ERR(emit_logs, + "%s: %s rcvd feature_idx: %u does not match with saved: %u", + arc->feature_arc_name, feature_name, slot, gf->this_feature_index); + return -1; + } + + if (is_enable_disable && (arc->feature_bit_mask_by_index[index] & + RTE_BIT64(slot))) { + FEAT_COND_ERR(emit_logs, "%s: %s already enabled on index: %u", + arc->feature_arc_name, feature_name, index); + return -1; + } + + if (!is_enable_disable && !arc->runtime_enabled_features) { + FEAT_COND_ERR(emit_logs, "%s: No feature enabled to disable", + arc->feature_arc_name); + return -1; + } + + if (!is_enable_disable && !(arc->feature_bit_mask_by_index[index] & RTE_BIT64(slot))) { + FEAT_COND_ERR(emit_logs, "%s: %s not enabled in bitmask for index: %u", + arc->feature_arc_name, feature_name, index); + return -1; + } + + return 0; +} + +/* + * Before switch to passive list, user_data needs to be copied from active list to passive list + */ +static void +copy_fastpath_user_data(struct rte_graph_feature_arc *arc, uint16_t dest_list_index, + uint16_t src_list_index) +{ + rte_graph_feature_data_t *sgfd = NULL, *dgfd = NULL; + struct rte_graph_feature *sgf = NULL, *dgf = NULL; + uint32_t i, j; + + for (i = 0; i < arc->max_features; i++) { + sgf = __rte_graph_feature_get(arc, i, src_list_index); + dgf = __rte_graph_feature_get(arc, i, dest_list_index); + for (j = 0; j < arc->max_indexes; j++) { + sgfd = rte_graph_feature_data_get(arc, sgf, j); + dgfd = rte_graph_feature_data_get(arc, dgf, j); + dgfd->user_data = sgfd->user_data; + } + } +} +/* + * Fill fast path information like + * - next_edge + * - next_enabled_feature + */ +static void +refill_feature_fastpath_data(struct rte_graph_feature_arc *arc, uint16_t list_index) +{ + struct rte_graph_feature_node_list *finfo = NULL, *prev_finfo = NULL; + struct rte_graph_feature_data *gfd = NULL, *prev_gfd = NULL; + uint32_t fi = UINT32_MAX, di = UINT32_MAX, prev_fi = UINT32_MAX; + struct rte_graph_feature *gf = NULL, *prev_gf = NULL; + rte_graph_feature_list_t *flist = NULL; + rte_edge_t edge = UINT16_MAX; + uint64_t bitmask = 0; + + flist = arc->feature_list[list_index]; + + for (di = 0; di < arc->max_indexes; di++) { + bitmask = arc->feature_bit_mask_by_index[di]; + prev_fi = RTE_GRAPH_FEATURE_INVALID; + /* for each feature set for index, set fast path data */ + while (rte_bsf64_safe(bitmask, &fi)) { + gf = __rte_graph_feature_get(arc, fi, list_index); + gfd = rte_graph_feature_data_get(arc, gf, di); + RTE_VERIFY(!feature_arc_node_info_lookup(arc, fi, &finfo, 1)); + + /* If previous feature_index was valid in last loop */ + if (prev_fi != RTE_GRAPH_FEATURE_INVALID) { + prev_gf = __rte_graph_feature_get(arc, prev_fi, list_index); + prev_gfd = rte_graph_feature_data_get(arc, prev_gf, di); + /* + * Get edge of previous feature node connecting + * to this feature node + */ + RTE_VERIFY(!feature_arc_node_info_lookup(arc, prev_fi, + &prev_finfo, 1)); + if (!get_existing_edge(arc->feature_arc_name, + prev_finfo->feature_node, + finfo->feature_node, &edge)) { + feat_dbg("\t[%s/%u/di:%2u,cookie:%u]: (%u->%u)%s[%u] = %s", + arc->feature_arc_name, list_index, di, + prev_gfd->user_data, prev_fi, fi, + prev_finfo->feature_node->name, + edge, finfo->feature_node->name); + /* Copy feature index for next iteration*/ + gfd->next_edge = edge; + prev_fi = fi; + /* + * Fill current feature as next enabled + * feature to previous one + */ + prev_gfd->next_enabled_feature = fi; + } else { + /* Should not fail */ + RTE_VERIFY(0); + } + } + /* On first feature edge of the node to be added */ + if (fi == rte_bsf64(arc->feature_bit_mask_by_index[di])) { + if (!get_existing_edge(arc->feature_arc_name, arc->start_node, + finfo->feature_node, + &edge)) { + feat_dbg("\t[%s/%u/di:%2u,cookie:%u]: (->%u)%s[%u]=%s", + arc->feature_arc_name, list_index, di, + gfd->user_data, fi, + arc->start_node->name, edge, + finfo->feature_node->name); + /* Copy feature index for next iteration*/ + gfd->next_edge = edge; + prev_fi = fi; + /* Set first feature set array for index*/ + flist->first_enabled_feature_by_index[di] = + (rte_graph_feature_t)fi; + } else { + /* Should not fail */ + RTE_VERIFY(0); + } + } + /* Clear current feature index */ + bitmask &= ~RTE_BIT64(fi); + } + } +} + +int +rte_graph_feature_enable(rte_graph_feature_arc_t _arc, uint32_t index, const + char *feature_name, int32_t user_data) +{ + struct rte_graph_feature_arc *arc = rte_graph_feature_arc_get(_arc); + rte_graph_feature_rt_list_t passive_list, active_list; + struct rte_graph_feature_node_list *finfo = NULL; + struct rte_graph_feature_data *gfd = NULL; + struct rte_graph_feature *gf = NULL; + uint64_t bitmask; + uint32_t slot; + + feat_dbg("%s: Enabling feature: %s for index: %u", + arc->feature_arc_name, feature_name, index); + + if (!arc->runtime_enabled_features) + prepare_feature_arc_before_first_enable(arc); + + if (rte_graph_feature_validate(_arc, index, feature_name, 1, true)) + return -1; + + /** This should not fail as validate() has passed */ + if (feature_lookup(arc, feature_name, &finfo, &slot)) + RTE_VERIFY(0); + + active_list = rte_atomic_load_explicit(&arc->active_feature_list, + rte_memory_order_relaxed); + + passive_list = ARC_PASSIVE_LIST(active_list); + + feat_dbg("\t%s/%s: index: %u, passive list: %u, feature index: %u", + arc->feature_arc_name, feature_name, index, passive_list, slot); + + gf = __rte_graph_feature_get(arc, slot, passive_list); + gfd = rte_graph_feature_data_get(arc, gf, index); + + /* Reset feature list */ + feature_arc_list_reset(arc, passive_list); + + /* Copy user-data */ + copy_fastpath_user_data(arc, passive_list, active_list); + + /* Set current user-data */ + gfd->user_data = user_data; + + /* Set bitmask in control path bitmask */ + rte_bit_relaxed_set64(rte_graph_uint_cast(slot), &arc->feature_bit_mask_by_index[index]); + refill_feature_fastpath_data(arc, passive_list); + + /* If first time feature getting enabled */ + bitmask = rte_atomic_load_explicit(&arc->feature_enable_bitmask[active_list], + rte_memory_order_relaxed); + + /* On very first feature enable instance */ + if (!finfo->ref_count) + bitmask |= RTE_BIT64(slot); + + rte_atomic_store_explicit(&arc->feature_enable_bitmask[passive_list], + bitmask, rte_memory_order_relaxed); + + /* Slow path updates */ + arc->runtime_enabled_features++; + + /* Increase feature node info reference count */ + finfo->ref_count++; + + /* Store release semantics for active_list update */ + rte_atomic_store_explicit(&arc->active_feature_list, passive_list, + rte_memory_order_release); + + feat_dbg("%s/%s: After enable, switched active feature list to %u", + arc->feature_arc_name, feature_name, passive_list); + + return 0; +} + +int +rte_graph_feature_disable(rte_graph_feature_arc_t _arc, uint32_t index, const char *feature_name) +{ + struct rte_graph_feature_arc *arc = rte_graph_feature_arc_get(_arc); + rte_graph_feature_rt_list_t passive_list, active_list; + struct rte_graph_feature_data *gfd = NULL; + struct rte_graph_feature_node_list *finfo = NULL; + struct rte_graph_feature *gf = NULL; + uint64_t bitmask; + uint32_t slot; + + feat_dbg("%s: Disable feature: %s for index: %u", + arc->feature_arc_name, feature_name, index); + + if (rte_graph_feature_validate(_arc, index, feature_name, 0, true)) + return -1; + + if (feature_lookup(arc, feature_name, &finfo, &slot)) + return -1; + + active_list = rte_atomic_load_explicit(&arc->active_feature_list, + rte_memory_order_relaxed); + + passive_list = ARC_PASSIVE_LIST(active_list); + + gf = __rte_graph_feature_get(arc, slot, passive_list); + gfd = rte_graph_feature_data_get(arc, gf, index); + + feat_dbg("\t%s/%s: index: %u, passive list: %u, feature index: %u", + arc->feature_arc_name, feature_name, index, passive_list, slot); + + rte_bit_relaxed_clear64(rte_graph_uint_cast(slot), &arc->feature_bit_mask_by_index[index]); + + /* Reset feature list */ + feature_arc_list_reset(arc, passive_list); + + /* Copy user-data */ + copy_fastpath_user_data(arc, passive_list, active_list); + + /* Reset current user-data */ + gfd->user_data = ~0; + + refill_feature_fastpath_data(arc, passive_list); + + finfo->ref_count--; + arc->runtime_enabled_features--; + + /* If no feature enabled, reset feature in u64 fast path bitmask */ + bitmask = rte_atomic_load_explicit(&arc->feature_enable_bitmask[active_list], + rte_memory_order_relaxed); + + /* When last feature is disabled */ + if (!finfo->ref_count) + bitmask &= ~(RTE_BIT64(slot)); + + rte_atomic_store_explicit(&arc->feature_enable_bitmask[passive_list], bitmask, + rte_memory_order_relaxed); + + /* Store release semantics for active_list update */ + rte_atomic_store_explicit(&arc->active_feature_list, passive_list, + rte_memory_order_release); + + feat_dbg("%s/%s: After disable, switched active feature list to %u", + arc->feature_arc_name, feature_name, passive_list); + + return 0; +} + +int +rte_graph_feature_arc_destroy(rte_graph_feature_arc_t _arc) +{ + struct rte_graph_feature_arc *arc = rte_graph_feature_arc_get(_arc); + rte_graph_feature_arc_main_t *dm = __rte_graph_feature_arc_main; + struct rte_graph_feature_node_list *node_info = NULL; + + while (!STAILQ_EMPTY(&arc->all_features)) { + node_info = STAILQ_FIRST(&arc->all_features); + STAILQ_REMOVE_HEAD(&arc->all_features, next_feature); + rte_free(node_info); + } + feature_arc_list_destroy(arc, 0); + feature_arc_list_destroy(arc, 1); + + dm->feature_arcs[arc->feature_arc_index] = RTE_GRAPH_FEATURE_ARC_INITIALIZER; + + rte_free(arc); + + do_sanity_all_arcs(); + + return 0; +} + +int +rte_graph_feature_arc_cleanup(void) +{ + rte_graph_feature_arc_main_t *dm = __rte_graph_feature_arc_main; + uint32_t iter; + + if (!__rte_graph_feature_arc_main) + return -1; + + for (iter = 0; iter < dm->max_feature_arcs; iter++) { + if (dm->feature_arcs[iter] == RTE_GRAPH_FEATURE_ARC_INITIALIZER) + continue; + + rte_graph_feature_arc_destroy((rte_graph_feature_arc_t)dm->feature_arcs[iter]); + } + rte_free(dm); + + __rte_graph_feature_arc_main = NULL; + + return 0; +} + +int +rte_graph_feature_arc_lookup_by_name(const char *arc_name, rte_graph_feature_arc_t *_arc) +{ + rte_graph_feature_arc_main_t *dm = __rte_graph_feature_arc_main; + struct rte_graph_feature_arc *arc = NULL; + uint32_t iter; + + if (!__rte_graph_feature_arc_main) + return -1; + + if (_arc) + *_arc = RTE_GRAPH_FEATURE_ARC_INITIALIZER; + + for (iter = 0; iter < dm->max_feature_arcs; iter++) { + if (dm->feature_arcs[iter] == RTE_GRAPH_FEATURE_ARC_INITIALIZER) + continue; + + arc = rte_graph_feature_arc_get(dm->feature_arcs[iter]); + + if ((strstr(arc->feature_arc_name, arc_name)) && + (strlen(arc->feature_arc_name) == strlen(arc_name))) { + if (_arc) + *_arc = (rte_graph_feature_arc_t)arc; + return 0; + } + } + + return -1; +} + +uint32_t +rte_graph_feature_arc_num_enabled_features(rte_graph_feature_arc_t _arc) +{ + struct rte_graph_feature_arc *arc = rte_graph_feature_arc_get(_arc); + + return arc->runtime_enabled_features; +} + +uint32_t +rte_graph_feature_arc_num_features(rte_graph_feature_arc_t _arc) +{ + struct rte_graph_feature_arc *arc = rte_graph_feature_arc_get(_arc); + struct rte_graph_feature_node_list *finfo = NULL; + uint32_t count = 0; + + STAILQ_FOREACH(finfo, &arc->all_features, next_feature) + count++; + + return count; +} + +char * +rte_graph_feature_arc_feature_to_name(rte_graph_feature_arc_t _arc, rte_graph_feature_t feat) +{ + struct rte_graph_feature_arc *arc = rte_graph_feature_arc_get(_arc); + struct rte_graph_feature_node_list *finfo = NULL; + uint32_t slot = feat; + + if (feat >= rte_graph_feature_arc_num_features(_arc)) { + graph_err("%s: feature %u does not exist", arc->feature_arc_name, feat); + return NULL; + } + if (!feature_arc_node_info_lookup(arc, slot, &finfo, 0/* ignore sanity*/)) + return finfo->feature_node->name; + + return NULL; +} + +struct rte_node_register * +rte_graph_feature_arc_feature_to_node(rte_graph_feature_arc_t _arc, rte_graph_feature_t feat) +{ + struct rte_graph_feature_arc *arc = rte_graph_feature_arc_get(_arc); + struct rte_graph_feature_node_list *finfo = NULL; + uint32_t slot = feat; + + if (feat >= rte_graph_feature_arc_num_features(_arc)) { + graph_err("%s: feature %u does not exist", arc->feature_arc_name, feat); + return NULL; + } + if (!feature_arc_node_info_lookup(arc, slot, &finfo, 0/* ignore sanity*/)) + return finfo->feature_node; + + return NULL; + +} diff --git a/lib/graph/meson.build b/lib/graph/meson.build index 0cb15442ab..d916176fb7 100644 --- a/lib/graph/meson.build +++ b/lib/graph/meson.build @@ -14,11 +14,13 @@ sources = files( 'graph_debug.c', 'graph_stats.c', 'graph_populate.c', + 'graph_feature_arc.c', 'graph_pcap.c', 'rte_graph_worker.c', 'rte_graph_model_mcore_dispatch.c', ) headers = files('rte_graph.h', 'rte_graph_worker.h') +headers += files('rte_graph_feature_arc.h', 'rte_graph_feature_arc_worker.h') indirect_headers += files( 'rte_graph_model_mcore_dispatch.h', 'rte_graph_model_rtc.h', diff --git a/lib/graph/rte_graph_feature_arc.h b/lib/graph/rte_graph_feature_arc.h new file mode 100644 index 0000000000..1615f8e1c8 --- /dev/null +++ b/lib/graph/rte_graph_feature_arc.h @@ -0,0 +1,431 @@ +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright(C) 2024 Marvell International Ltd. + */ + +#ifndef _RTE_GRAPH_FEATURE_ARC_H_ +#define _RTE_GRAPH_FEATURE_ARC_H_ + +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * @file + * + * rte_graph_feature_arc.h + * + * Define APIs and structures/variables with respect to feature arc + * + * - Feature arc(s) + * - Feature(s) + * + * A feature arc represents an ordered list of features/protocol-nodes at a + * given networking layer. Feature arc provides a high level abstraction to + * connect various *rte_graph* nodes, designated as *feature nodes*, and + * allowing steering of packets across these feature nodes fast path processing + * in a generic manner. In a typical network stack, often a protocol or feature + * must be first enabled on a given interface, before any packet is steered + * towards it for feature processing. For eg: incoming IPv4 packets are sent to + * routing sub-system only after a valid IPv4 address is assigned to the + * received interface. In other words, often packets needs to be steered across + * features not based on the packet content but based on whether a feature is + * enable or disable on a given incoming/outgoing interface. Feature arc + * provides mechanism to enable/disable feature(s) on each interface at runtime + * and allow seamless packet steering across runtime enabled feature nodes in + * fast path. + * + * Feature arc also provides a way to steer packets from standard nodes to + * custom/user-defined *feature nodes* without any change in standard node's + * fast path functions + * + * On a given interface multiple feature(s) might be enabled in a particular + * feature arc. For instance, both "ipv4-output" and "IPsec policy output" + * features may be enabled on "eth0" interface in "L3-output" feature arc. + * Similarly, "ipv6-output" and "ipsec-output" may be enabled on "eth1" + * interface in same "L3-output" feature arc. + * + * When multiple features are present in a given feature arc, its imperative + * to allow each feature processing in a particular sequential order. For + * instance, in "L3-input" feature arc it may be required to run "IPsec + * input" feature first, for packet decryption, before "ip-lookup". So a + * sequential order must be maintained among features present in a feature arc. + * + * Features are enabled/disabled multiple times at runtime to some or all + * available interfaces present in the system. Enable/disabling features on one + * interface is independent of other interface. + * + * A given feature might consume packet (if it's configured to consume) or may + * forward it to next enabled feature. For instance, "IPsec input" feature may + * consume/drop all packets with "Protect" policy action while all packets with + * policy action as "Bypass" may be forwarded to next enabled feature (with in + * same feature arc) + * + * This library facilitates rte graph based applications to steer packets in + * fast path to different feature nodes with-in a feature arc and support all + * functionalities described above + * + * In order to use feature-arc APIs, applications needs to do following in + * control path: + * - Initialize feature arc library via rte_graph_feature_arc_init() + * - Create feature arc via rte_graph_feature_arc_create() + * - *Before calling rte_graph_create()*, features must be added to feature-arc + * via rte_graph_feature_add(). rte_graph_feature_add() allows adding + * features in a sequential order with "runs_after" and "runs_before" + * constraints. + * - Post rte_graph_create(), features can be enabled/disabled at runtime on + * any interface via rte_graph_feature_enable()/rte_graph_feature_disable() + * - Feature arc can be destroyed via rte_graph_feature_arc_destroy() + * + * In fast path, APIs are provided to steer packets towards feature path from + * - start_node (provided as an argument to rte_graph_feature_arc_create()) + * - feature nodes (which are added via rte_graph_feature_add()) + * + * For typical steering of packets across feature nodes, application required + * to know "rte_edges" which are saved in feature data object. Feature data + * object is unique for every interface per feature with in a feature arc. + * + * When steering packets from start_node to feature node: + * - rte_graph_feature_arc_first_feature_get() provides first enabled feature. + * - Next rte_edge from start_node to first enabled feature can be obtained via + * rte_graph_feature_arc_feature_set() + * + * rte_mbuf can carry [current feature, interface index] from start_node of an + * arc to other feature nodes + * + * At the time of feature enable(rte_graph_feature_enable), application can set + * 32-bit unique user_data specific to feature per interface. In fast path + * user_data can be retrieved via rte_graph_feature_user_data_get(). User data + * can hold application specific cookie like IPsec policy database index, FIB + * table index etc. + * + * If feature node is not consuming packet, next enabled feature and next + * rte_edge can be obtained via rte_graph_feature_arc_next_feature_get() + * + * It is application responsibility to ensure that at-least *last feature*(or + * sink feature) must be enabled from where packet can exit feature-arc path, + * if *NO* intermediate feature is consuming the packet and it has reached till + * the end of feature arc path + * + * It is recommended that all features *MUST* be added to feature arc before + * calling `rte_graph_create()`. Addition of features after + * `rte_graph_create()` may not work functionally. + * Although,rte_graph_feature_enable()/rte_graph_feature_disable() should be + * called after `rte_graph_create()` in control plane. + * + * Synchronization among cores + * --------------------------- + * Subsequent calls to rte_graph_feature_enable() is allowed while worker cores + * are processing in rte_graph_walk() loop. However, for + * rte_graph_feature_disable() application must use RCU based synchronization + */ + +/** Initializer value for rte_graph_feature_arc_t */ +#define RTE_GRAPH_FEATURE_ARC_INITIALIZER ((rte_graph_feature_arc_t)UINT64_MAX) + +/** Max number of feature arcs which can be created */ +#define RTE_GRAPH_FEATURE_ARC_MAX 64 + +/** Max number of features supported in a given feature arc */ +#define RTE_GRAPH_FEATURE_MAX_PER_ARC 64 + +/** Length of feature arc name */ +#define RTE_GRAPH_FEATURE_ARC_NAMELEN RTE_NODE_NAMESIZE + +/** @internal */ +#define rte_graph_feature_cast(x) ((rte_graph_feature_t)x) + +/**< Initializer value for rte_graph_feature_arc_t */ +#define RTE_GRAPH_FEATURE_INVALID rte_graph_feature_cast(UINT8_MAX) + +/** rte_graph feature arc object */ +typedef uintptr_t rte_graph_feature_arc_t; + +/** rte_graph feature object */ +typedef uint8_t rte_graph_feature_t; + +/** runtime active feature list index with in feature arc*/ +typedef uint16_t rte_graph_feature_rt_list_t; + +/** per feature arc monotonically increasing counter to synchronize fast path APIs */ +typedef uint16_t rte_graph_feature_counter_t; + +/** + * Initialize feature arc subsystem + * + * @param max_feature_arcs + * Maximum number of feature arcs required to be supported + * + * @return + * 0: Success + * <0: Failure + */ +__rte_experimental +int rte_graph_feature_arc_init(int max_feature_arcs); + +/** + * Create a feature arc + * + * @param feature_arc_name + * Feature arc name with max length of @ref RTE_GRAPH_FEATURE_ARC_NAMELEN + * @param max_features + * Maximum number of features to be supported in this feature arc + * @param max_indexes + * Maximum number of interfaces/ports/indexes to be supported + * @param start_node + * Base node where this feature arc's features are checked in fast path + * @param[out] _arc + * Feature arc object + * + * @return + * 0: Success + * <0: Failure + */ +__rte_experimental +int rte_graph_feature_arc_create(const char *feature_arc_name, int max_features, int max_indexes, + struct rte_node_register *start_node, + rte_graph_feature_arc_t *_arc); + +/** + * Get feature arc object with name + * + * @param arc_name + * Feature arc name provided to successful @ref rte_graph_feature_arc_create + * @param[out] _arc + * Feature arc object returned. Valid only when API returns SUCCESS + * + * @return + * 0: Success + * <0: Failure. + */ +__rte_experimental +int rte_graph_feature_arc_lookup_by_name(const char *arc_name, rte_graph_feature_arc_t *_arc); + +/** + * Add a feature to already created feature arc. For instance + * + * 1. Add first feature node: "ipv4-input" to input arc + * rte_graph_feature_add(ipv4_input_arc, "ipv4-input", NULL, NULL); + * + * 2. Add "ipsec-input" feature node after "ipv4-input" feature + * rte_graph_feature_add(ipv4_input_arc, "ipsec-input", "ipv4-input", NULL); + * + * 3. Add "ipv4-pre-classify-input" node before "ipv4-input" feature + * rte_graph_feature_add(ipv4_input_arc, "ipv4-pre-classify-input"", NULL, "ipv4-input"); + * + * 4. Add "acl-classify-input" node after ipv4-input but before ipsec-input + * rte_graph_feature_add(ipv4_input_arc, "acl-classify-input", "ipv4-input", "ipsec-input"); + * + * @param _arc + * Feature arc handle returned from @ref rte_graph_feature_arc_create() + * @param feature_node + * Graph node representing feature. On success, feature_node is next_node of + * feature_arc->start_node + * @param runs_after + * Add this feature_node after already added "runs_after". Creates + * start_node -> runs_after -> this_feature sequence + * @param runs_before + * Add this feature_node before already added "runs_before". Creates + * start_node -> this_feature -> runs_before sequence + * + * Must be called before rte_graph_create() + * rte_graph_feature_add() is not allowed after call to + * rte_graph_feature_enable() so all features must be added before they can be + * enabled + * + * @return + * 0: Success + * <0: Failure + */ +__rte_experimental +int rte_graph_feature_add(rte_graph_feature_arc_t _arc, struct rte_node_register *feature_node, + const char *runs_after, const char *runs_before); + +/** + * Enable feature within a feature arc + * + * Must be called after @b rte_graph_create(). + * + * @param _arc + * Feature arc object returned by @ref rte_graph_feature_arc_create or @ref + * rte_graph_feature_arc_lookup_by_name + * @param index + * Application specific index. Can be corresponding to interface_id/port_id etc + * @param feature_name + * Name of the node which is already added via @ref rte_graph_feature_add + * @param user_data + * Application specific data which is retrieved in fast path + * + * @return + * 0: Success + * <0: Failure + */ +__rte_experimental +int rte_graph_feature_enable(rte_graph_feature_arc_t _arc, uint32_t index, const char *feature_name, + int32_t user_data); + +/** + * Validate whether subsequent enable/disable feature would succeed or not. + * API is thread-safe + * + * @param _arc + * Feature arc object returned by @ref rte_graph_feature_arc_create or @ref + * rte_graph_feature_arc_lookup_by_name + * @param index + * Application specific index. Can be corresponding to interface_id/port_id etc + * @param feature_name + * Name of the node which is already added via @ref rte_graph_feature_add + * @param is_enable_disable + * If 1, validate whether subsequent @ref rte_graph_feature_enable would pass or not + * If 0, validate whether subsequent @ref rte_graph_feature_disable would pass or not + * @param emit_logs + * If passed true, emit error logs when failure is returned + * If passed false, do not emit error logs when failure is returned + * + * @return + * 0: Subsequent enable/disable API would pass + * <0: Subsequent enable/disable API would not pass + */ +__rte_experimental +int rte_graph_feature_validate(rte_graph_feature_arc_t _arc, uint32_t index, + const char *feature_name, int is_enable_disable, bool emit_logs); + +/** + * Disable already enabled feature within a feature arc + * + * Must be called after @b rte_graph_create(). API is *NOT* Thread-safe + * + * @param _arc + * Feature arc object returned by @ref rte_graph_feature_arc_create or @ref + * rte_graph_feature_arc_lookup_by_name + * @param index + * Application specific index. Can be corresponding to interface_id/port_id etc + * @param feature_name + * Name of the node which is already added via @ref rte_graph_feature_add + * + * @return + * 0: Success + * <0: Failure + */ +__rte_experimental +int rte_graph_feature_disable(rte_graph_feature_arc_t _arc, uint32_t index, + const char *feature_name); + +/** + * Get rte_graph_feature_t object from feature name + * + * @param arc + * Feature arc object returned by @ref rte_graph_feature_arc_create or @ref + * rte_graph_feature_arc_lookup_by_name + * @param feature_name + * Feature name provided to @ref rte_graph_feature_add + * @param[out] feature + * Feature object + * + * @return + * 0: Success + * <0: Failure + */ +__rte_experimental +int rte_graph_feature_lookup(rte_graph_feature_arc_t arc, const char *feature_name, + rte_graph_feature_t *feature); + +/** + * Delete feature_arc object + * + * @param _arc + * Feature arc object returned by @ref rte_graph_feature_arc_create or @ref + * rte_graph_feature_arc_lookup_by_name + * + * @return + * 0: Success + * <0: Failure + */ +__rte_experimental +int rte_graph_feature_arc_destroy(rte_graph_feature_arc_t _arc); + +/** + * Cleanup all feature arcs + * + * @return + * 0: Success + * <0: Failure + */ +__rte_experimental +int rte_graph_feature_arc_cleanup(void); + +/** + * Slow path API to know how many features are added (NOT enabled) within a + * feature arc + * + * @param _arc + * Feature arc object + * + * @return: Number of added features to arc + */ +__rte_experimental +uint32_t rte_graph_feature_arc_num_features(rte_graph_feature_arc_t _arc); + +/** + * Slow path API to know how many features are currently enabled within a + * feature arc across all indexes. If a single feature is enabled on all interfaces, + * this API would return "number_of_interfaces" as count (but not "1") + * + * @param _arc + * Feature arc object + * + * @return: Number of enabled features across all indexes + */ +__rte_experimental +uint32_t rte_graph_feature_arc_num_enabled_features(rte_graph_feature_arc_t _arc); + +/** + * Slow path API to get feature node name from rte_graph_feature_t object + * + * @param _arc + * Feature arc object + * @param feature + * Feature object + * + * @return: Name of the feature node + */ +__rte_experimental +char *rte_graph_feature_arc_feature_to_name(rte_graph_feature_arc_t _arc, + rte_graph_feature_t feature); + +/** + * Slow path API to get corresponding struct rte_node_register * from + * rte_graph_feature_t + * + * @param _arc + * Feature arc object + * @param feature + * Feature object + * + * @return: struct rte_node_register * of feature node on SUCCESS else NULL + */ +__rte_experimental +struct rte_node_register * +rte_graph_feature_arc_feature_to_node(rte_graph_feature_arc_t _arc, + rte_graph_feature_t feature); + + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/lib/graph/rte_graph_feature_arc_worker.h b/lib/graph/rte_graph_feature_arc_worker.h new file mode 100644 index 0000000000..9b720e366c --- /dev/null +++ b/lib/graph/rte_graph_feature_arc_worker.h @@ -0,0 +1,679 @@ +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright(C) 2024 Marvell International Ltd. + */ + +#ifndef _RTE_GRAPH_FEATURE_ARC_WORKER_H_ +#define _RTE_GRAPH_FEATURE_ARC_WORKER_H_ + +#include +#include +#include + +/** + * @file + * + * rte_graph_feature_arc_worker.h + * + * Defines fast path structure + */ + +#ifdef __cplusplus +extern "C" { +#endif + +/** @internal + * + * Slow path feature node info list + */ +struct rte_graph_feature_node_list { + /** Next feature */ + STAILQ_ENTRY(rte_graph_feature_node_list) next_feature; + + /** node representing feature */ + struct rte_node_register *feature_node; + + /** How many indexes/interfaces using this feature */ + int32_t ref_count; + + /* node_index in list (after feature_enable())*/ + uint32_t node_index; + + /** Back pointer to feature arc */ + void *feature_arc; + + /** rte_edge_t to this feature node from feature_arc->start_node */ + rte_edge_t edge_to_this_feature; +}; + +/** + * Feature data object: + * + * Feature data stores information to steer packets for: + * - a feature with in feature arc + * - Index i.e. Port/Interface index + * + * Each feature data object holds + * - User data of current feature retrieved via rte_graph_feature_user_data_get() + * - next_edge is used in two conditions when packet to be steered from + * -- start_node to first enabled feature on an interface index + * -- current feature node to next enabled feature on an interface index + * - next_enabled_feature on interface index, if current feature is not + * consuming packet + * + * While user_data corresponds to current enabled feature node however + * next_edge and next_enabled_feature corresponds to next enabled feature + * node on an interface index + * + * First enabled feature on interface index can be retrieved via: + * - rte_graph_feature_first_feature_get() if arc's start_node is trying to + * steer packet from start_node to first enabled feature on interface index + * + * Next enabled feature on interface index can be retrieved via: + * - rte_graph_feature_next_feature_get() if current node is not arc's + * start_node. Input to rte_graph_feature_next_feature_get() is current + * enabled feature and interface index + */ +typedef struct __rte_packed rte_graph_feature_data { + /** edge from current node to next enabled feature */ + rte_edge_t next_edge; + + union { + uint16_t reserved; + struct { + /** next enabled feature on index from current feature */ + rte_graph_feature_t next_enabled_feature; + }; + }; + + /** user_data set by application in rte_graph_feature_enable() for + * - current feature + * - interface index + */ + int32_t user_data; +} rte_graph_feature_data_t; + +/** + * Feature object + * + * Feature object holds feature data object for every index/interface within + * feature + * + * Within a given arc and interface index, first feature object can be + * retrieved in arc's start_node via: + * - rte_graph_feature_arc_first_feature_get() + * + * Feature data information can be retrieved for first feature in start node via + * - rte_graph_feature_arc_feature_set() + * + * Next enabled feature on interface index can be retrieved via: + * - rte_graph_feature_arc_next_feature_get() + * + * Typically application stores rte_graph_feature_t object in rte_mbuf. + * rte_graph_feature_t can be translated to (struct rte_graph_feature *) via + * rte_graph_feature_get() in fast path. Further if needed, feature data for an + * index within a feature can be retrieved via rte_graph_feature_data_get() + */ +struct __rte_cache_aligned rte_graph_feature { + /** feature index or rte_graph_feature_t */ + uint16_t this_feature_index; + + /* + * Array of size arc->feature_data_size + * + * <----------------- Feature --------------------------> + * [data-index-0][data-index-1]...[data-index-max_index-1] + * + * sizeof(feature_data_by_index[0] == sizeof(rte_graph_feature_data_t) + * + */ + uint8_t feature_data_by_index[]; +}; + +/** + * Feature list object + * + * Feature list is required to decouple fast path APIs with control path APIs. + * + * There are two feature lists: active, passive + * Passive list is duplicate of active list in terms of memory. + * + * While fast path APIs always work on active list but control plane work on + * passive list. When control plane needs to enable/disable any feature, it + * populates passive list afresh and atomically switch passive list to active + * list to make it available for fast path APIs + * + * Each feature node in start of its fast path function, must grab active list from + * arc via + * - rte_graph_feature_arc_has_any_feature() or + * rte_graph_feature_arc_has_feature() + * + * Retrieved list must be provided to other feature arc fast path APIs so that + * any control plane changes of active list should not impact current node + * execution iteration. Active list change would be reflected to current node + * in next iteration + * + * With active/passive lists and RCU mechanism in graph worker + * loop, application can update features at runtime without stopping fast path + * cores. A RCU synchronization is required when a feature needs to be + * disabled via rte_graph_feature_disable(). On enabling a feature, RCU + * synchronization may not be required + * + */ +typedef struct __rte_cache_aligned rte_graph_feature_list { + /** + * fast path array holding per_feature data. + * Duplicate entry as feature-arc also hold this pointer + * arc->features[] + * + *<-------------feature-0 ---------><---------feature-1 -------------->... + *[index-0][index-1]...[max_index-1]<-ALIGN->[index-0][index-1] ...[max_index-1]... + */ + struct rte_graph_feature *indexed_by_features; + /* + * fast path array holding first enabled feature per index + * (Required in start_node. In non start_node, mbuf can hold next enabled + * feature) + */ + rte_graph_feature_t first_enabled_feature_by_index[]; +} rte_graph_feature_list_t; + +/** + * rte_graph Feature arc object + * + * Feature arc object holds control plane and fast path information for all + * features and all interface index information for steering packets across + * feature nodes + * + * Within a feature arc, only RTE_GRAPH_FEATURE_MAX_PER_ARC features can be + * added. If more features needs to be added, another feature arc can be + * created + * + * Application gets rte_graph_feature_arc_t object via + * - rte_graph_feature_arc_create() OR + * - rte_graph_feature_arc_lookup_by_name() + * + * In fast path, rte_graph_feature_arc_t can be translated to (struct + * rte_graph_feature_arc *) via rte_graph_feature_arc_get(). Later is needed to + * add as an input argument to all fast path feature arc APIs + */ +struct __rte_cache_aligned rte_graph_feature_arc { + /* First 64B is fast path variables */ + RTE_MARKER fast_path_variables; + + /** runtime active feature list */ + RTE_ATOMIC(rte_graph_feature_rt_list_t) active_feature_list; + + /** Actual Size of feature_list object */ + uint16_t feature_list_size; + + /** + * Size each feature in fastpath. + * Required to navigate from feature to another feature in fast path + */ + uint16_t feature_size; + + /** + * Size of all feature data for an index + * Required to navigate through various feature data within a feature + * in fast path + */ + uint16_t feature_data_size; + + /** + * Quick fast path bitmask indicating if any feature enabled or not on + * any of the indexes. Helps in optimally process packets for the case + * when features are added but not enabled + * + * Separate for active and passive list + */ + RTE_ATOMIC(uint64_t) feature_enable_bitmask[2]; + + /** + * Pointer to both active and passive feature list object + */ + rte_graph_feature_list_t *feature_list[2]; + + /** + * Feature objects for each list + */ + struct rte_graph_feature *features[2]; + + /** index in feature_arc_main */ + uint16_t feature_arc_index; + + uint16_t reserved[3]; + + /** Slow path variables follows*/ + RTE_MARKER slow_path_variables; + + /** feature arc name */ + char feature_arc_name[RTE_GRAPH_FEATURE_ARC_NAMELEN]; + + /** All feature lists */ + STAILQ_HEAD(, rte_graph_feature_node_list) all_features; + + /** control plane counter to track enabled features */ + uint32_t runtime_enabled_features; + + /** Back pointer to feature_arc_main */ + void *feature_arc_main; + + /** Arc's start/base node */ + struct rte_node_register *start_node; + + /** maximum number of features supported by this arc */ + uint32_t max_features; + + /** maximum number of index supported by this arc */ + uint32_t max_indexes; + + /** Slow path bit mask per feature per index */ + uint64_t feature_bit_mask_by_index[]; +}; + +/** + * Feature arc main object + * + * Holds all feature arcs created by application + * + * RTE_GRAPH_FEATURE_ARC_MAX number of feature arcs can be created by + * application via rte_graph_feature_arc_create() + */ +typedef struct feature_arc_main { + /** number of feature arcs created by application */ + uint32_t num_feature_arcs; + + /** max features arcs allowed */ + uint32_t max_feature_arcs; + + /** feature arcs */ + rte_graph_feature_arc_t feature_arcs[]; +} rte_graph_feature_arc_main_t; + +/** @internal Get feature arc pointer from object */ +#define rte_graph_feature_arc_get(arc) ((struct rte_graph_feature_arc *)arc) + +extern rte_graph_feature_arc_main_t *__feature_arc_main; + +/** + * API to know if feature is valid or not + */ +__rte_experimental +static __rte_always_inline int +rte_graph_feature_is_valid(rte_graph_feature_t feature) +{ + return (feature != RTE_GRAPH_FEATURE_INVALID); +} + +/** + * Get rte_graph_feature object with no checks + * + * @param arc + * Feature arc pointer + * @param feature + * Feature index + * @param feature_list + * active feature list retrieved from rte_graph_feature_arc_has_any_feature() + * or rte_graph_feature_arc_has_feature() + * + * @return + * Internal feature object. + */ +__rte_experimental +static __rte_always_inline struct rte_graph_feature * +__rte_graph_feature_get(struct rte_graph_feature_arc *arc, rte_graph_feature_t feature, + const rte_graph_feature_rt_list_t feature_list) +{ + return ((struct rte_graph_feature *)(((uint8_t *)arc->features[feature_list]) + + (feature * arc->feature_size))); +} + +/** + * Get rte_graph_feature object for a given interface/index from feature arc + * + * @param arc + * Feature arc pointer + * @param feature + * Feature index + * + * @return + * Internal feature object. + */ +__rte_experimental +static __rte_always_inline struct rte_graph_feature * +rte_graph_feature_get(struct rte_graph_feature_arc *arc, rte_graph_feature_t feature) +{ + rte_graph_feature_rt_list_t list; + + if (unlikely(feature >= arc->max_features)) + RTE_VERIFY(0); + + if (likely(rte_graph_feature_is_valid(feature))) { + list = rte_atomic_load_explicit(&arc->active_feature_list, + rte_memory_order_relaxed); + return __rte_graph_feature_get(arc, feature, list); + } + + return NULL; +} + +__rte_experimental +static __rte_always_inline rte_graph_feature_data_t * +__rte_graph_feature_data_get(struct rte_graph_feature_arc *arc, struct rte_graph_feature *feature, + uint8_t index) +{ + RTE_SET_USED(arc); + return ((rte_graph_feature_data_t *)(((uint8_t *)feature->feature_data_by_index) + + (index * sizeof(rte_graph_feature_data_t)))); +} + +/** + * Get rte_graph feature data object for a index in feature + * + * @param arc + * feature arc + * @param feature + * Pointer to feature object + * @param index + * Index of feature maintained in slow path linked list + * + * @return + * Valid feature data + */ +__rte_experimental +static __rte_always_inline rte_graph_feature_data_t * +rte_graph_feature_data_get(struct rte_graph_feature_arc *arc, struct rte_graph_feature *feature, + uint8_t index) +{ + if (likely(index < arc->max_indexes)) + return __rte_graph_feature_data_get(arc, feature, index); + + RTE_VERIFY(0); +} + +/** + * Fast path API to check if any feature enabled on a feature arc + * Typically from arc->start_node process function + * + * @param arc + * Feature arc object + * @param[out] plist + * Pointer to runtime active feature list which needs to be provided to other + * fast path APIs + * + * @return + * 0: If no feature enabled + * Non-Zero: Bitmask of features enabled. plist is valid + * + */ +__rte_experimental +static __rte_always_inline uint64_t +rte_graph_feature_arc_has_any_feature(struct rte_graph_feature_arc *arc, + rte_graph_feature_rt_list_t *plist) +{ + *plist = rte_atomic_load_explicit(&arc->active_feature_list, rte_memory_order_relaxed); + + return (rte_atomic_load_explicit(arc->feature_enable_bitmask + (uint8_t)*plist, + rte_memory_order_relaxed)); +} + +/** + * Fast path API to check if provided feature is enabled on any interface/index + * or not + * + * @param arc + * Feature arc object + * @param feature + * Input rte_graph_feature_t that needs to be checked + * @param[out] plist + * Returns active list to caller which needs to be provided to other fast path + * APIs + * + * @return + * 1: If input [feature] is enabled in arc + * 0: If input [feature] is not enabled in arc + */ +__rte_experimental +static __rte_always_inline int +rte_graph_feature_arc_has_feature(struct rte_graph_feature_arc *arc, + rte_graph_feature_t feature, + rte_graph_feature_rt_list_t *plist) +{ + uint64_t bitmask = RTE_BIT64(feature); + + *plist = rte_atomic_load_explicit(&arc->active_feature_list, rte_memory_order_relaxed); + + return (bitmask & rte_atomic_load_explicit(arc->feature_enable_bitmask + (uint8_t)*plist, + rte_memory_order_relaxed)); +} + +/** + * Prefetch feature arc fast path cache line + * + * @param arc + * RTE_GRAPH feature arc object + */ +__rte_experimental +static __rte_always_inline void +rte_graph_feature_arc_prefetch(struct rte_graph_feature_arc *arc) +{ + rte_prefetch0((void *)&arc->fast_path_variables); +} + +/** + * Prefetch feature related fast path cache line + * + * @param arc + * RTE_GRAPH feature arc object + * @param list + * Pointer to runtime active feature list from rte_graph_feature_arc_has_any_feature(); + * @param feature + * Pointer to feature object + */ +__rte_experimental +static __rte_always_inline void +rte_graph_feature_arc_feature_prefetch(struct rte_graph_feature_arc *arc, + const rte_graph_feature_rt_list_t list, + rte_graph_feature_t feature) +{ + /* feature cache line */ + if (likely(rte_graph_feature_is_valid(feature))) + rte_prefetch0((void *)__rte_graph_feature_get(arc, feature, list)); +} + +/** + * Prefetch feature data upfront. Perform sanity + * + * @param arc + * RTE_GRAPH feature arc object + * @param list + * Pointer to runtime active feature list from rte_graph_feature_arc_has_any_feature(); + * @param feature + * Pointer to feature object returned from @ref + * rte_graph_feature_arc_first_feature_get() + * @param index + * Interface/index + */ +__rte_experimental +static __rte_always_inline void +rte_graph_feature_arc_data_prefetch(struct rte_graph_feature_arc *arc, + const rte_graph_feature_rt_list_t list, + rte_graph_feature_t feature, uint32_t index) +{ + if (likely(rte_graph_feature_is_valid(feature))) + rte_prefetch0((void *)((uint8_t *)arc->features[list] + + offsetof(struct rte_graph_feature, feature_data_by_index) + + (index * sizeof(rte_graph_feature_data_t)))); +} + +/** + * Fast path API to get first enabled feature on interface index + * Typically required in arc->start_node so that from returned feature, + * feature-data can be retrieved to steer packets + * + * @param arc + * Feature arc object + * @param list + * Pointer to runtime active feature list from + * rte_graph_feature_arc_has_any_feature() or + * rte_graph_feature_arc_has_feature() + * @param index + * Interface Index + * @param[out] feature + * Pointer to rte_graph_feature_t. + * + * @return + * 1. Success. If first feature field is enabled and returned [feature] is valid + * 0. Failure. If first feature field is disabled in arc + * + */ +__rte_experimental +static __rte_always_inline int +rte_graph_feature_arc_first_feature_get(struct rte_graph_feature_arc *arc, + const rte_graph_feature_rt_list_t list, + uint32_t index, + rte_graph_feature_t *feature) +{ + struct rte_graph_feature_list *feature_list = arc->feature_list[list]; + + *feature = feature_list->first_enabled_feature_by_index[index]; + + return rte_graph_feature_is_valid(*feature); +} + +/** + * Fast path API to get next enabled feature on interface index with provided + * input feature + * + * @param arc + * Feature arc object + * @param list + * Pointer to runtime active feature list from + * rte_graph_feature_arc_has_any_feature() or + * @param index + * Interface Index + * @param[out] feature + * Pointer to rte_graph_feature_t. API sets next enabled feature on [index] + * from provided input feature. Valid only if API returns Success + * @param[out] next_edge + * Edge from current feature to next feature. Valid only if next feature is valid + * + * @return + * 1. Success. first feature field is enabled/valid + * 0. Failure. first feature field is disabled/invalid + */ +__rte_experimental +static __rte_always_inline int +rte_graph_feature_arc_next_feature_get(struct rte_graph_feature_arc *arc, + const rte_graph_feature_rt_list_t list, + uint32_t index, + rte_graph_feature_t *feature, + rte_edge_t *next_edge) +{ + rte_graph_feature_data_t *feature_data = NULL; + struct rte_graph_feature *f = NULL; + + if (likely(rte_graph_feature_is_valid(*feature))) { + f = __rte_graph_feature_get(arc, *feature, list); + feature_data = rte_graph_feature_data_get(arc, f, index); + *feature = feature_data->next_enabled_feature; + *next_edge = feature_data->next_edge; + return rte_graph_feature_is_valid(*feature); + } + + return 0; +} + +/** + * Set fields with respect to first enabled feature in an arc and return edge + * Typically returned feature and interface index must be saved in rte_mbuf + * structure to pass this information to next feature node + * + * @param arc + * Feature arc object + * @param list + * Pointer to runtime active feature list from rte_graph_feature_arc_has_any_feature(); + * @param index + * Index (of interface) + * @param[out] gf + * Pointer to rte_graph_feature_t. Valid if API returns Success + * @param[out] edge + * Edge to steer packet from arc->start_node to first enabled feature. Valid + * only if API returns Success + * + * @return + * 0: If valid feature is enabled and set by API in *gf + * 1: If valid feature is NOT enabled + */ +__rte_experimental +static __rte_always_inline rte_graph_feature_t +rte_graph_feature_arc_feature_set(struct rte_graph_feature_arc *arc, + const rte_graph_feature_rt_list_t list, + uint32_t index, + rte_graph_feature_t *gf, + rte_edge_t *edge) +{ + struct rte_graph_feature_list *feature_list = arc->feature_list[list]; + struct rte_graph_feature_data *feature_data = NULL; + struct rte_graph_feature *feature = NULL; + rte_graph_feature_t f; + + f = feature_list->first_enabled_feature_by_index[index]; + + if (unlikely(rte_graph_feature_is_valid(f))) { + feature = __rte_graph_feature_get(arc, f, list); + feature_data = rte_graph_feature_data_get(arc, feature, index); + *gf = f; + *edge = feature_data->next_edge; + return 0; + } + + return 1; +} + +__rte_experimental +static __rte_always_inline int32_t +__rte_graph_feature_user_data_get(rte_graph_feature_data_t *fdata) +{ + return fdata->user_data; +} + +/** + * Get user data corresponding to current feature set by application in + * rte_graph_feature_enable() + * + * @param arc + * Feature arc object + * @param list + * Pointer to runtime active feature list from rte_graph_feature_arc_has_any_feature(); + * @param feature + * Feature index + * @param index + * Interface index + * + * @return + * -1: Failure + * Valid user data: Success + */ +__rte_experimental +static __rte_always_inline int32_t +rte_graph_feature_user_data_get(struct rte_graph_feature_arc *arc, + const rte_graph_feature_rt_list_t list, + rte_graph_feature_t feature, + uint32_t index) +{ + rte_graph_feature_data_t *fdata = NULL; + struct rte_graph_feature *f = NULL; + + if (likely(rte_graph_feature_is_valid(feature))) { + f = __rte_graph_feature_get(arc, feature, list); + fdata = rte_graph_feature_data_get(arc, f, index); + return __rte_graph_feature_user_data_get(fdata); + } + + return -1; +} +#ifdef __cplusplus +} +#endif +#endif diff --git a/lib/graph/version.map b/lib/graph/version.map index 2c83425ddc..3b7f475afd 100644 --- a/lib/graph/version.map +++ b/lib/graph/version.map @@ -52,3 +52,23 @@ DPDK_25 { local: *; }; + +EXPERIMENTAL { + global: + + # added in 24.11 + rte_graph_feature_arc_init; + rte_graph_feature_arc_create; + rte_graph_feature_arc_lookup_by_name; + rte_graph_feature_add; + rte_graph_feature_enable; + rte_graph_feature_validate; + rte_graph_feature_disable; + rte_graph_feature_lookup; + rte_graph_feature_arc_destroy; + rte_graph_feature_arc_cleanup; + rte_graph_feature_arc_num_enabled_features; + rte_graph_feature_arc_num_features; + rte_graph_feature_arc_feature_to_name; + rte_graph_feature_arc_feature_to_node; +}; From patchwork Thu Oct 10 13:31:03 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Nitin Saxena X-Patchwork-Id: 145604 X-Patchwork-Delegate: thomas@monjalon.net Return-Path: X-Original-To: patchwork@inbox.dpdk.org Delivered-To: patchwork@inbox.dpdk.org Received: from mails.dpdk.org (mails.dpdk.org [217.70.189.124]) by inbox.dpdk.org (Postfix) with ESMTP id E159145B04; Thu, 10 Oct 2024 15:31:57 +0200 (CEST) Received: from mails.dpdk.org (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id 24E7540662; Thu, 10 Oct 2024 15:31:39 +0200 (CEST) Received: from mx0a-0016f401.pphosted.com (mx0a-0016f401.pphosted.com [67.231.148.174]) by mails.dpdk.org (Postfix) with ESMTP id 5B9DE40653 for ; Thu, 10 Oct 2024 15:31:35 +0200 (CEST) Received: from pps.filterd (m0431384.ppops.net [127.0.0.1]) by mx0a-0016f401.pphosted.com (8.18.1.2/8.18.1.2) with ESMTP id 49A9mBhg025242; Thu, 10 Oct 2024 06:31:31 -0700 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=marvell.com; h= cc:content-transfer-encoding:content-type:date:from:in-reply-to :message-id:mime-version:references:subject:to; s=pfpt0220; bh=k tJMzjUgXK4uYh9h21folAkx6s8MqdwQH0yOuhrVn78=; b=QBbchr8RGZs1d1wbo U8glFjRZCXA6w1Jv9OOuu9NNtni2qYVRScSnPO+5R628C9qAKetoego9ABAi4cT7 gtzf092vMEY65sd+5S5qfe6r+WY7IA3KrZTHFdNUA2afhaV2ElzQjO3/phvrXxjw JLX6w0bbnoY/Sw2tt+UykJsswR6I8bTj5u40tV1kYCpcZfGMuOYbwK1WnOTS5G/Z 2zn6qvD4fGlY8iJwGBO1+YCNgSoj0My/AS5AlOQtRywI0fUnBnqSy/M/CYuBm75G hLcHIirXVvXrvp2l1f2cB0jejPX9sICvj23AT0Vkj/nkM9z/5lpv8g00YYsFauio A1UGg== Received: from dc6wp-exch02.marvell.com ([4.21.29.225]) by mx0a-0016f401.pphosted.com (PPS) with ESMTPS id 426ckmgbhx-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Thu, 10 Oct 2024 06:31:31 -0700 (PDT) Received: from DC6WP-EXCH02.marvell.com (10.76.176.209) by DC6WP-EXCH02.marvell.com (10.76.176.209) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.2.1544.4; Thu, 10 Oct 2024 06:31:21 -0700 Received: from maili.marvell.com (10.69.176.80) by DC6WP-EXCH02.marvell.com (10.76.176.209) with Microsoft SMTP Server id 15.2.1544.4 via Frontend Transport; Thu, 10 Oct 2024 06:31:21 -0700 Received: from cavium-PowerEdge-R640.. (unknown [10.28.36.207]) by maili.marvell.com (Postfix) with ESMTP id 6D0833F7051; Thu, 10 Oct 2024 06:31:18 -0700 (PDT) From: Nitin Saxena To: Jerin Jacob , Kiran Kumar K , Nithin Dabilpuram , Zhirun Yan , Robin Jarry , Christophe Fontaine CC: , Nitin Saxena , Pavan Nikhilesh Subject: [PATCH v4 2/5] graph: add feature arc option in graph create Date: Thu, 10 Oct 2024 19:01:03 +0530 Message-ID: <20241010133111.2764712-3-nsaxena@marvell.com> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20241010133111.2764712-1-nsaxena@marvell.com> References: <20241009133009.1152321-1-nsaxena@marvell.com> <20241010133111.2764712-1-nsaxena@marvell.com> MIME-Version: 1.0 X-Proofpoint-ORIG-GUID: ub5Ke9KlXv77Ju1LoQMDE_IVH_QMravG X-Proofpoint-GUID: ub5Ke9KlXv77Ju1LoQMDE_IVH_QMravG X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.293,Aquarius:18.0.687,Hydra:6.0.235,FMLib:17.0.607.475 definitions=2020-10-13_15,2020-10-13_02,2020-04-07_01 X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org Added option in graph create to call feature-specific process node functions. This removes extra overhead for checking feature arc status in nodes where application is not using feature arc processing Signed-off-by: Pavan Nikhilesh Signed-off-by: Nitin Saxena --- doc/guides/rel_notes/release_24_11.rst | 7 +++++++ lib/graph/graph.c | 1 + lib/graph/graph_populate.c | 7 ++++++- lib/graph/graph_private.h | 3 +++ lib/graph/node.c | 2 ++ lib/graph/rte_graph.h | 3 +++ 6 files changed, 22 insertions(+), 1 deletion(-) diff --git a/doc/guides/rel_notes/release_24_11.rst b/doc/guides/rel_notes/release_24_11.rst index bd5589b01c..237c057647 100644 --- a/doc/guides/rel_notes/release_24_11.rst +++ b/doc/guides/rel_notes/release_24_11.rst @@ -137,6 +137,13 @@ ABI Changes Also, make sure to start the actual text at the margin. ======================================================= +* graph: Added feature arc specific `feat_arc_proc` node callback function in + `struct rte_node_register`. If this function is not NULL and + `feature_arc_enable` is set to `true` in `struct rte_graph_param`, + rte_graph_walk() calls `feat_arc_proc` callback function instead of `process` + +* graph: Added `feature_arc_enable` parameter in `struct rte_graph_param` for + calling non-NULL `feat_arc_proc` callback function by `rte_graph_walk()` Known Issues ------------ diff --git a/lib/graph/graph.c b/lib/graph/graph.c index d5b8c9f918..b0ad3a83ae 100644 --- a/lib/graph/graph.c +++ b/lib/graph/graph.c @@ -455,6 +455,7 @@ rte_graph_create(const char *name, struct rte_graph_param *prm) graph->parent_id = RTE_GRAPH_ID_INVALID; graph->lcore_id = RTE_MAX_LCORE; graph->num_pkt_to_capture = prm->num_pkt_to_capture; + graph->feature_arc_enabled = prm->feature_arc_enable; if (prm->pcap_filename) rte_strscpy(graph->pcap_filename, prm->pcap_filename, RTE_GRAPH_PCAP_FILE_SZ); diff --git a/lib/graph/graph_populate.c b/lib/graph/graph_populate.c index ed596a7711..5d8aa7b903 100644 --- a/lib/graph/graph_populate.c +++ b/lib/graph/graph_populate.c @@ -79,8 +79,13 @@ graph_nodes_populate(struct graph *_graph) if (graph_pcap_is_enable()) { node->process = graph_pcap_dispatch; node->original_process = graph_node->node->process; - } else + if (_graph->feature_arc_enabled && graph_node->node->feat_arc_proc) + node->original_process = graph_node->node->feat_arc_proc; + } else { node->process = graph_node->node->process; + if (_graph->feature_arc_enabled && graph_node->node->feat_arc_proc) + node->process = graph_node->node->feat_arc_proc; + } memcpy(node->name, graph_node->node->name, RTE_GRAPH_NAMESIZE); pid = graph_node->node->parent_id; if (pid != RTE_NODE_ID_INVALID) { /* Cloned node */ diff --git a/lib/graph/graph_private.h b/lib/graph/graph_private.h index d557d55f2d..58ba0abeff 100644 --- a/lib/graph/graph_private.h +++ b/lib/graph/graph_private.h @@ -56,6 +56,7 @@ struct node { unsigned int lcore_id; /**< Node runs on the Lcore ID used for mcore dispatch model. */ rte_node_process_t process; /**< Node process function. */ + rte_node_process_t feat_arc_proc; /**< Node feature-arch process function. */ rte_node_init_t init; /**< Node init function. */ rte_node_fini_t fini; /**< Node fini function. */ rte_node_t id; /**< Allocated identifier for the node. */ @@ -126,6 +127,8 @@ struct graph { /**< Number of packets to be captured per core. */ char pcap_filename[RTE_GRAPH_PCAP_FILE_SZ]; /**< pcap file name/path. */ + uint8_t feature_arc_enabled; + /**< Graph feature arc. */ STAILQ_HEAD(gnode_list, graph_node) node_list; /**< Nodes in a graph. */ }; diff --git a/lib/graph/node.c b/lib/graph/node.c index 99a9622779..d8fd273543 100644 --- a/lib/graph/node.c +++ b/lib/graph/node.c @@ -90,6 +90,7 @@ __rte_node_register(const struct rte_node_register *reg) goto free; node->flags = reg->flags; node->process = reg->process; + node->feat_arc_proc = reg->feat_arc_proc; node->init = reg->init; node->fini = reg->fini; node->nb_edges = reg->nb_edges; @@ -137,6 +138,7 @@ node_clone(struct node *node, const char *name) /* Clone the source node */ reg->flags = node->flags; reg->process = node->process; + reg->feat_arc_proc = node->feat_arc_proc; reg->init = node->init; reg->fini = node->fini; reg->nb_edges = node->nb_edges; diff --git a/lib/graph/rte_graph.h b/lib/graph/rte_graph.h index ecfec2068a..f07272b308 100644 --- a/lib/graph/rte_graph.h +++ b/lib/graph/rte_graph.h @@ -172,6 +172,8 @@ struct rte_graph_param { uint32_t mp_capacity; /**< Capacity of memory pool for dispatch model. */ } dispatch; }; + + bool feature_arc_enable; /**< Enable Graph feature arc. */ }; /** @@ -470,6 +472,7 @@ struct rte_node_register { uint64_t flags; /**< Node configuration flag. */ #define RTE_NODE_SOURCE_F (1ULL << 0) /**< Node type is source. */ rte_node_process_t process; /**< Node process function. */ + rte_node_process_t feat_arc_proc; /**< Node feature-arc specific process function. */ rte_node_init_t init; /**< Node init function. */ rte_node_fini_t fini; /**< Node fini function. */ rte_node_t id; /**< Node Identifier. */ From patchwork Thu Oct 10 13:31:04 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Nitin Saxena X-Patchwork-Id: 145603 X-Patchwork-Delegate: thomas@monjalon.net Return-Path: X-Original-To: patchwork@inbox.dpdk.org Delivered-To: patchwork@inbox.dpdk.org Received: from mails.dpdk.org (mails.dpdk.org [217.70.189.124]) by inbox.dpdk.org (Postfix) with ESMTP id 4843245B04; Thu, 10 Oct 2024 15:31:47 +0200 (CEST) Received: from mails.dpdk.org (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id DF91F40653; Thu, 10 Oct 2024 15:31:35 +0200 (CEST) Received: from mx0a-0016f401.pphosted.com (mx0a-0016f401.pphosted.com [67.231.148.174]) by mails.dpdk.org (Postfix) with ESMTP id 8ECF74065C for ; Thu, 10 Oct 2024 15:31:34 +0200 (CEST) Received: from pps.filterd (m0431384.ppops.net [127.0.0.1]) by mx0a-0016f401.pphosted.com (8.18.1.2/8.18.1.2) with ESMTP id 49A9l2kr023861; Thu, 10 Oct 2024 06:31:31 -0700 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=marvell.com; h= cc:content-transfer-encoding:content-type:date:from:in-reply-to :message-id:mime-version:references:subject:to; s=pfpt0220; bh=J E298fOSiUT24LOS9pMYhOlPoaypmERM+TcHK+zF3i4=; b=H02gqoJ2FAgg8c7uW Wy0CYPKOHxn1uTZKzbocj3NHLu9Fb+g+bSieKG7gk16OCeJbNiCi/WhW9m38zfjM Wbryc4SXKXJv+TIy7El6TiunCosM//QoQ5wRO+CnRtFme8qwJbJ7t34p0P/bgzTZ kM5TU+PkmiCuo3CyZ16Zazb+/tn5aoz2P0sXSgeTPHp5148Oxf6pLZ5w4PQ9etly yM8Xpi5JZY7vvStrTZh5gusQgK55MQ4/D1KW7FaNVkFnQdX0eyrSmN57ppRngO6K rGW9zw4duRa16zz7INJD49eku1u5nCfBuhJ06YS0W0aYEorPJI09IOOgzqyxEPF0 xl0cA== Received: from dc5-exch05.marvell.com ([199.233.59.128]) by mx0a-0016f401.pphosted.com (PPS) with ESMTPS id 426ckmgbj5-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Thu, 10 Oct 2024 06:31:30 -0700 (PDT) Received: from DC5-EXCH05.marvell.com (10.69.176.209) by DC5-EXCH05.marvell.com (10.69.176.209) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.2.1544.4; Thu, 10 Oct 2024 06:31:24 -0700 Received: from maili.marvell.com (10.69.176.80) by DC5-EXCH05.marvell.com (10.69.176.209) with Microsoft SMTP Server id 15.2.1544.4 via Frontend Transport; Thu, 10 Oct 2024 06:31:24 -0700 Received: from cavium-PowerEdge-R640.. (unknown [10.28.36.207]) by maili.marvell.com (Postfix) with ESMTP id 9F39D3F7051; Thu, 10 Oct 2024 06:31:21 -0700 (PDT) From: Nitin Saxena To: Jerin Jacob , Kiran Kumar K , Nithin Dabilpuram , Zhirun Yan , Robin Jarry , Christophe Fontaine CC: , Nitin Saxena Subject: [PATCH v4 3/5] graph: add IPv4 output feature arc Date: Thu, 10 Oct 2024 19:01:04 +0530 Message-ID: <20241010133111.2764712-4-nsaxena@marvell.com> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20241010133111.2764712-1-nsaxena@marvell.com> References: <20241009133009.1152321-1-nsaxena@marvell.com> <20241010133111.2764712-1-nsaxena@marvell.com> MIME-Version: 1.0 X-Proofpoint-ORIG-GUID: V98lFZ7dXIVbLxHKzYwlcJVPcgtisMBG X-Proofpoint-GUID: V98lFZ7dXIVbLxHKzYwlcJVPcgtisMBG X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.293,Aquarius:18.0.687,Hydra:6.0.235,FMLib:17.0.607.475 definitions=2020-10-13_15,2020-10-13_02,2020-04-07_01 X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org add ipv4-output feature arc in ipv4-rewrite node to allow custom/standard nodes(like outbound IPsec policy node) in outgoing forwarding path Signed-off-by: Nitin Saxena --- lib/node/ip4_rewrite.c | 476 +++++++++++++++++++++++++++++------- lib/node/ip4_rewrite_priv.h | 15 +- lib/node/node_private.h | 20 +- lib/node/rte_node_ip4_api.h | 3 + 4 files changed, 417 insertions(+), 97 deletions(-) diff --git a/lib/node/ip4_rewrite.c b/lib/node/ip4_rewrite.c index 34a920df5e..824ef9a4cd 100644 --- a/lib/node/ip4_rewrite.c +++ b/lib/node/ip4_rewrite.c @@ -15,39 +15,156 @@ #include "ip4_rewrite_priv.h" #include "node_private.h" +#define ALL_PKT_MASK 0xf + struct ip4_rewrite_node_ctx { + rte_graph_feature_arc_t output_feature_arc; /* Dynamic offset to mbuf priv1 */ int mbuf_priv1_off; /* Cached next index */ uint16_t next_index; + uint16_t last_tx; }; +typedef struct rewrite_priv_vars { + union { + struct { + rte_xmm_t xmm1; + }; + struct __rte_packed { + uint16_t next0; + uint16_t next1; + uint16_t next2; + uint16_t next3; + uint16_t last_tx_interface; + uint16_t last_if_feature; + uint16_t actual_feat_mask; + uint16_t speculative_feat_mask; + }; + }; +} rewrite_priv_vars_t; + static struct ip4_rewrite_node_main *ip4_rewrite_nm; #define IP4_REWRITE_NODE_LAST_NEXT(ctx) \ (((struct ip4_rewrite_node_ctx *)ctx)->next_index) +#define IP4_REWRITE_NODE_LAST_TX(ctx) \ + (((struct ip4_rewrite_node_ctx *)ctx)->last_tx) + #define IP4_REWRITE_NODE_PRIV1_OFF(ctx) \ (((struct ip4_rewrite_node_ctx *)ctx)->mbuf_priv1_off) -static uint16_t -ip4_rewrite_node_process(struct rte_graph *graph, struct rte_node *node, - void **objs, uint16_t nb_objs) +#define IP4_REWRITE_NODE_OUTPUT_FEATURE_ARC(ctx) \ + (((struct ip4_rewrite_node_ctx *)ctx)->output_feature_arc) + +static __rte_always_inline void +prefetch_mbuf_and_dynfield(struct rte_mbuf *mbuf) { + /* prefetch first cache line required for accessing buf_addr */ + rte_prefetch0((void *)mbuf); +} + +static __rte_always_inline void +check_output_feature_x4(struct rte_graph_feature_arc *arc, + const rte_graph_feature_rt_list_t flist, + rewrite_priv_vars_t *pvar, struct node_mbuf_priv1 *priv0, + struct node_mbuf_priv1 *priv1, struct node_mbuf_priv1 *priv2, + struct node_mbuf_priv1 *priv3) +{ + uint32_t mask = 0; + uint16_t xor = 0; + + /* + * interface edge's start from 1 and not from 0 as "pkt_drop" + * is next node at 0th index + */ + priv0->if_index = pvar->next0 - 1; + priv1->if_index = pvar->next1 - 1; + priv2->if_index = pvar->next2 - 1; + priv3->if_index = pvar->next3 - 1; + + /* Find out if all packets are sent to last_tx_interface */ + xor = pvar->last_tx_interface ^ priv0->if_index; + xor += priv0->if_index ^ priv1->if_index; + xor += priv1->if_index ^ priv2->if_index; + xor += priv2->if_index ^ priv3->if_index; + + if (likely(!xor)) { + /* copy last interface feature and feature mask */ + priv0->current_feature = priv1->current_feature = + priv2->current_feature = priv3->current_feature = + pvar->last_if_feature; + pvar->actual_feat_mask = pvar->speculative_feat_mask; + } else { + /* create a mask for index which does not have feature + * Also override next edge and if feature enabled, get feature + */ + mask = rte_graph_feature_arc_feature_set(arc, flist, priv0->if_index, + &priv0->current_feature, + &pvar->next0); + + mask |= ((rte_graph_feature_arc_feature_set(arc, flist, priv1->if_index, + &priv1->current_feature, + &pvar->next1)) << 1); + + mask |= ((rte_graph_feature_arc_feature_set(arc, flist, priv2->if_index, + &priv2->current_feature, + &pvar->next2)) << 2); + + mask |= ((rte_graph_feature_arc_feature_set(arc, flist, priv3->if_index, + &priv3->current_feature, + &pvar->next3)) << 3); + + /* + * add last tx and last feature regardless even if feature is + * valid or not + */ + pvar->last_tx_interface = priv3->if_index; + pvar->last_if_feature = priv3->current_feature; + /* Set 0xf if invalid feature to last packet, else 0 */ + pvar->speculative_feat_mask = (priv3->current_feature == + RTE_GRAPH_FEATURE_INVALID) ? ALL_PKT_MASK : 0x0; + pvar->actual_feat_mask = mask; + } +} + +static __rte_always_inline uint16_t +__ip4_rewrite_node_process(struct rte_graph *graph, struct rte_node *node, + void **objs, uint16_t nb_objs, + const int dyn, const int check_enabled_features, + struct rte_graph_feature_arc *out_feature_arc, + const rte_graph_feature_rt_list_t flist) +{ + struct node_mbuf_priv1 *priv0 = NULL, *priv1 = NULL, *priv2 = NULL, *priv3 = NULL; struct rte_mbuf *mbuf0, *mbuf1, *mbuf2, *mbuf3, **pkts; struct ip4_rewrite_nh_header *nh = ip4_rewrite_nm->nh; - const int dyn = IP4_REWRITE_NODE_PRIV1_OFF(node->ctx); - uint16_t next0, next1, next2, next3, next_index; - struct rte_ipv4_hdr *ip0, *ip1, *ip2, *ip3; uint16_t n_left_from, held = 0, last_spec = 0; + struct rte_ipv4_hdr *ip0, *ip1, *ip2, *ip3; + rewrite_priv_vars_t pvar; + int64_t fd0, fd1, fd2, fd3; + rte_edge_t fix_spec = 0; void *d0, *d1, *d2, *d3; void **to_next, **from; + uint16_t next_index; rte_xmm_t priv01; rte_xmm_t priv23; int i; - /* Speculative next as last next */ + RTE_SET_USED(fd0); + RTE_SET_USED(fd1); + RTE_SET_USED(fd2); + RTE_SET_USED(fd3); + + /* Initialize speculative variables.*/ + + /* Last interface */ + pvar.last_tx_interface = IP4_REWRITE_NODE_LAST_TX(node->ctx); + /*last next from node ctx*/ next_index = IP4_REWRITE_NODE_LAST_NEXT(node->ctx); + pvar.speculative_feat_mask = ALL_PKT_MASK; + pvar.actual_feat_mask = 0; + rte_prefetch0(nh); pkts = (struct rte_mbuf **)objs; @@ -55,20 +172,47 @@ ip4_rewrite_node_process(struct rte_graph *graph, struct rte_node *node, n_left_from = nb_objs; for (i = 0; i < 4 && i < n_left_from; i++) - rte_prefetch0(pkts[i]); + prefetch_mbuf_and_dynfield(pkts[i]); /* Get stream for the speculated next node */ to_next = rte_node_next_stream_get(graph, node, next_index, nb_objs); + + /* prefetch speculative feature and corresponding data */ + if (check_enabled_features) { + /* + * Get first feature enabled, if any, on last_tx_interface + */ + if (unlikely(rte_graph_feature_arc_first_feature_get(out_feature_arc, + flist, + pvar.last_tx_interface, + (rte_graph_feature_t *) + &pvar.last_if_feature))) { + /* prefetch feature cache line */ + rte_graph_feature_arc_feature_prefetch(out_feature_arc, flist, + pvar.last_if_feature); + + /* prefetch feature data cache line */ + rte_graph_feature_arc_data_prefetch(out_feature_arc, flist, + pvar.last_if_feature, + pvar.last_tx_interface); + /* + * Set speculativa_feat mask to indicate, all 4 packets + * going to feature path + */ + pvar.speculative_feat_mask = 0; + } + } + /* Update Ethernet header of pkts */ while (n_left_from >= 4) { if (likely(n_left_from > 7)) { /* Prefetch only next-mbuf struct and priv area. * Data need not be prefetched as we only write. */ - rte_prefetch0(pkts[4]); - rte_prefetch0(pkts[5]); - rte_prefetch0(pkts[6]); - rte_prefetch0(pkts[7]); + prefetch_mbuf_and_dynfield(pkts[4]); + prefetch_mbuf_and_dynfield(pkts[5]); + prefetch_mbuf_and_dynfield(pkts[6]); + prefetch_mbuf_and_dynfield(pkts[7]); } mbuf0 = pkts[0]; @@ -78,66 +222,138 @@ ip4_rewrite_node_process(struct rte_graph *graph, struct rte_node *node, pkts += 4; n_left_from -= 4; + + /* Copy mbuf private data into private variables */ priv01.u64[0] = node_mbuf_priv1(mbuf0, dyn)->u; priv01.u64[1] = node_mbuf_priv1(mbuf1, dyn)->u; priv23.u64[0] = node_mbuf_priv1(mbuf2, dyn)->u; priv23.u64[1] = node_mbuf_priv1(mbuf3, dyn)->u; - /* Increment checksum by one. */ - priv01.u32[1] += rte_cpu_to_be_16(0x0100); - priv01.u32[3] += rte_cpu_to_be_16(0x0100); - priv23.u32[1] += rte_cpu_to_be_16(0x0100); - priv23.u32[3] += rte_cpu_to_be_16(0x0100); - - /* Update ttl,cksum rewrite ethernet hdr on mbuf0 */ - d0 = rte_pktmbuf_mtod(mbuf0, void *); - rte_memcpy(d0, nh[priv01.u16[0]].rewrite_data, - nh[priv01.u16[0]].rewrite_len); - - next0 = nh[priv01.u16[0]].tx_node; - ip0 = (struct rte_ipv4_hdr *)((uint8_t *)d0 + - sizeof(struct rte_ether_hdr)); - ip0->time_to_live = priv01.u16[1] - 1; - ip0->hdr_checksum = priv01.u16[2] + priv01.u16[3]; - - /* Update ttl,cksum rewrite ethernet hdr on mbuf1 */ - d1 = rte_pktmbuf_mtod(mbuf1, void *); - rte_memcpy(d1, nh[priv01.u16[4]].rewrite_data, - nh[priv01.u16[4]].rewrite_len); - - next1 = nh[priv01.u16[4]].tx_node; - ip1 = (struct rte_ipv4_hdr *)((uint8_t *)d1 + - sizeof(struct rte_ether_hdr)); - ip1->time_to_live = priv01.u16[5] - 1; - ip1->hdr_checksum = priv01.u16[6] + priv01.u16[7]; - - /* Update ttl,cksum rewrite ethernet hdr on mbuf2 */ - d2 = rte_pktmbuf_mtod(mbuf2, void *); - rte_memcpy(d2, nh[priv23.u16[0]].rewrite_data, - nh[priv23.u16[0]].rewrite_len); - next2 = nh[priv23.u16[0]].tx_node; - ip2 = (struct rte_ipv4_hdr *)((uint8_t *)d2 + - sizeof(struct rte_ether_hdr)); - ip2->time_to_live = priv23.u16[1] - 1; - ip2->hdr_checksum = priv23.u16[2] + priv23.u16[3]; - - /* Update ttl,cksum rewrite ethernet hdr on mbuf3 */ - d3 = rte_pktmbuf_mtod(mbuf3, void *); - rte_memcpy(d3, nh[priv23.u16[4]].rewrite_data, - nh[priv23.u16[4]].rewrite_len); - - next3 = nh[priv23.u16[4]].tx_node; - ip3 = (struct rte_ipv4_hdr *)((uint8_t *)d3 + - sizeof(struct rte_ether_hdr)); - ip3->time_to_live = priv23.u16[5] - 1; - ip3->hdr_checksum = priv23.u16[6] + priv23.u16[7]; + /* Copy next edge from next hop */ + pvar.next0 = nh[priv01.u16[0]].tx_node; + pvar.next1 = nh[priv01.u16[4]].tx_node; + pvar.next2 = nh[priv23.u16[0]].tx_node; + pvar.next3 = nh[priv23.u16[4]].tx_node; + + if (check_enabled_features) { + priv0 = node_mbuf_priv1(mbuf0, dyn); + priv1 = node_mbuf_priv1(mbuf1, dyn); + priv2 = node_mbuf_priv1(mbuf2, dyn); + priv3 = node_mbuf_priv1(mbuf3, dyn); + + /* If feature is enabled, override next edge for each mbuf + * and set node_mbuf_priv data appropriately + */ + check_output_feature_x4(out_feature_arc, flist, + &pvar, priv0, priv1, priv2, priv3); + + /* check_output_feature_x4() returns bit mask which indicates + * which packet is not following feature path, hence normal processing + * has to happen on them + */ + if (unlikely(pvar.actual_feat_mask)) { + if (pvar.actual_feat_mask & 0x1) { + priv01.u32[1] += rte_cpu_to_be_16(0x0100); + /* Update ttl,cksum rewrite ethernet hdr on mbuf0 */ + d0 = rte_pktmbuf_mtod(mbuf0, void *); + rte_memcpy(d0, nh[priv01.u16[0]].rewrite_data, + nh[priv01.u16[0]].rewrite_len); + ip0 = (struct rte_ipv4_hdr *)((uint8_t *)d0 + + sizeof(struct rte_ether_hdr)); + ip0->time_to_live = priv01.u16[1] - 1; + ip0->hdr_checksum = priv01.u16[2] + priv01.u16[3]; + } + if (pvar.actual_feat_mask & 0x2) { + priv01.u32[3] += rte_cpu_to_be_16(0x0100); + /* Update ttl,cksum rewrite ethernet hdr on mbuf1 */ + d1 = rte_pktmbuf_mtod(mbuf1, void *); + rte_memcpy(d1, nh[priv01.u16[4]].rewrite_data, + nh[priv01.u16[4]].rewrite_len); + + ip1 = (struct rte_ipv4_hdr *)((uint8_t *)d1 + + sizeof(struct rte_ether_hdr)); + ip1->time_to_live = priv01.u16[5] - 1; + ip1->hdr_checksum = priv01.u16[6] + priv01.u16[7]; + } + if (pvar.actual_feat_mask & 0x4) { + priv23.u32[1] += rte_cpu_to_be_16(0x0100); + /* Update ttl,cksum rewrite ethernet hdr on mbuf2 */ + d2 = rte_pktmbuf_mtod(mbuf2, void *); + rte_memcpy(d2, nh[priv23.u16[0]].rewrite_data, + nh[priv23.u16[0]].rewrite_len); + ip2 = (struct rte_ipv4_hdr *)((uint8_t *)d2 + + sizeof(struct rte_ether_hdr)); + ip2->time_to_live = priv23.u16[1] - 1; + ip2->hdr_checksum = priv23.u16[2] + priv23.u16[3]; + } + if (pvar.actual_feat_mask & 0x8) { + priv23.u32[3] += rte_cpu_to_be_16(0x0100); + /* Update ttl,cksum rewrite ethernet hdr on mbuf3 */ + d3 = rte_pktmbuf_mtod(mbuf3, void *); + rte_memcpy(d3, nh[priv23.u16[4]].rewrite_data, + nh[priv23.u16[4]].rewrite_len); + ip3 = (struct rte_ipv4_hdr *)((uint8_t *)d3 + + sizeof(struct rte_ether_hdr)); + ip3->time_to_live = priv23.u16[5] - 1; + ip3->hdr_checksum = priv23.u16[6] + priv23.u16[7]; + } + } + } else { + /* Case when no feature is enabled */ + + /* Increment checksum by one. */ + priv01.u32[1] += rte_cpu_to_be_16(0x0100); + priv01.u32[3] += rte_cpu_to_be_16(0x0100); + priv23.u32[1] += rte_cpu_to_be_16(0x0100); + priv23.u32[3] += rte_cpu_to_be_16(0x0100); + + /* Update ttl,cksum rewrite ethernet hdr on mbuf0 */ + d0 = rte_pktmbuf_mtod(mbuf0, void *); + rte_memcpy(d0, nh[priv01.u16[0]].rewrite_data, + nh[priv01.u16[0]].rewrite_len); + + ip0 = (struct rte_ipv4_hdr *)((uint8_t *)d0 + + sizeof(struct rte_ether_hdr)); + ip0->time_to_live = priv01.u16[1] - 1; + ip0->hdr_checksum = priv01.u16[2] + priv01.u16[3]; + + /* Update ttl,cksum rewrite ethernet hdr on mbuf1 */ + d1 = rte_pktmbuf_mtod(mbuf1, void *); + rte_memcpy(d1, nh[priv01.u16[4]].rewrite_data, + nh[priv01.u16[4]].rewrite_len); + + ip1 = (struct rte_ipv4_hdr *)((uint8_t *)d1 + + sizeof(struct rte_ether_hdr)); + ip1->time_to_live = priv01.u16[5] - 1; + ip1->hdr_checksum = priv01.u16[6] + priv01.u16[7]; + + /* Update ttl,cksum rewrite ethernet hdr on mbuf2 */ + d2 = rte_pktmbuf_mtod(mbuf2, void *); + rte_memcpy(d2, nh[priv23.u16[0]].rewrite_data, + nh[priv23.u16[0]].rewrite_len); + ip2 = (struct rte_ipv4_hdr *)((uint8_t *)d2 + + sizeof(struct rte_ether_hdr)); + ip2->time_to_live = priv23.u16[1] - 1; + ip2->hdr_checksum = priv23.u16[2] + priv23.u16[3]; + + /* Update ttl,cksum rewrite ethernet hdr on mbuf3 */ + d3 = rte_pktmbuf_mtod(mbuf3, void *); + rte_memcpy(d3, nh[priv23.u16[4]].rewrite_data, + nh[priv23.u16[4]].rewrite_len); + + ip3 = (struct rte_ipv4_hdr *)((uint8_t *)d3 + + sizeof(struct rte_ether_hdr)); + ip3->time_to_live = priv23.u16[5] - 1; + ip3->hdr_checksum = priv23.u16[6] + priv23.u16[7]; + } /* Enqueue four to next node */ - rte_edge_t fix_spec = - ((next_index == next0) && (next0 == next1) && - (next1 == next2) && (next2 == next3)); + fix_spec = next_index ^ pvar.next0; + fix_spec += next_index ^ pvar.next1; + fix_spec += next_index ^ pvar.next2; + fix_spec += next_index ^ pvar.next3; - if (unlikely(fix_spec == 0)) { + if (unlikely(fix_spec != 0)) { /* Copy things successfully speculated till now */ rte_memcpy(to_next, from, last_spec * sizeof(from[0])); from += last_spec; @@ -146,56 +362,56 @@ ip4_rewrite_node_process(struct rte_graph *graph, struct rte_node *node, last_spec = 0; /* next0 */ - if (next_index == next0) { + if (next_index == pvar.next0) { to_next[0] = from[0]; to_next++; held++; } else { - rte_node_enqueue_x1(graph, node, next0, + rte_node_enqueue_x1(graph, node, pvar.next0, from[0]); } /* next1 */ - if (next_index == next1) { + if (next_index == pvar.next1) { to_next[0] = from[1]; to_next++; held++; } else { - rte_node_enqueue_x1(graph, node, next1, + rte_node_enqueue_x1(graph, node, pvar.next1, from[1]); } /* next2 */ - if (next_index == next2) { + if (next_index == pvar.next2) { to_next[0] = from[2]; to_next++; held++; } else { - rte_node_enqueue_x1(graph, node, next2, + rte_node_enqueue_x1(graph, node, pvar.next2, from[2]); } /* next3 */ - if (next_index == next3) { + if (next_index == pvar.next3) { to_next[0] = from[3]; to_next++; held++; } else { - rte_node_enqueue_x1(graph, node, next3, + rte_node_enqueue_x1(graph, node, pvar.next3, from[3]); } from += 4; /* Change speculation if last two are same */ - if ((next_index != next3) && (next2 == next3)) { + if ((next_index != pvar.next3) && (pvar.next2 == pvar.next3)) { /* Put the current speculated node */ rte_node_next_stream_put(graph, node, next_index, held); held = 0; /* Get next speculated stream */ - next_index = next3; + next_index = pvar.next3; to_next = rte_node_next_stream_get( graph, node, next_index, nb_objs); } @@ -212,20 +428,41 @@ ip4_rewrite_node_process(struct rte_graph *graph, struct rte_node *node, pkts += 1; n_left_from -= 1; - d0 = rte_pktmbuf_mtod(mbuf0, void *); - rte_memcpy(d0, nh[node_mbuf_priv1(mbuf0, dyn)->nh].rewrite_data, - nh[node_mbuf_priv1(mbuf0, dyn)->nh].rewrite_len); - - next0 = nh[node_mbuf_priv1(mbuf0, dyn)->nh].tx_node; - ip0 = (struct rte_ipv4_hdr *)((uint8_t *)d0 + - sizeof(struct rte_ether_hdr)); - chksum = node_mbuf_priv1(mbuf0, dyn)->cksum + - rte_cpu_to_be_16(0x0100); - chksum += chksum >= 0xffff; - ip0->hdr_checksum = chksum; - ip0->time_to_live = node_mbuf_priv1(mbuf0, dyn)->ttl - 1; - - if (unlikely(next_index ^ next0)) { + pvar.next0 = nh[node_mbuf_priv1(mbuf0, dyn)->nh].tx_node; + if (check_enabled_features) { + priv0 = node_mbuf_priv1(mbuf0, dyn); + if (pvar.next0 != (pvar.last_tx_interface + 1)) { + priv0->if_index = pvar.next0 - 1; + rte_graph_feature_arc_feature_set(out_feature_arc, flist, + priv0->if_index, + &priv0->current_feature, + &pvar.next0); + pvar.last_tx_interface = priv0->if_index; + pvar.last_if_feature = priv0->current_feature; + } else { + /* current mbuf index is same as last_tx_interface */ + priv0->if_index = pvar.last_tx_interface; + priv0->current_feature = pvar.last_if_feature; + } + } + /* Do the needful if either feature arc is disabled OR + * Invalid feature is present + */ + if (!check_enabled_features || + (priv0->current_feature == RTE_GRAPH_FEATURE_INVALID)) { + d0 = rte_pktmbuf_mtod(mbuf0, void *); + rte_memcpy(d0, nh[node_mbuf_priv1(mbuf0, dyn)->nh].rewrite_data, + nh[node_mbuf_priv1(mbuf0, dyn)->nh].rewrite_len); + + ip0 = (struct rte_ipv4_hdr *)((uint8_t *)d0 + + sizeof(struct rte_ether_hdr)); + chksum = node_mbuf_priv1(mbuf0, dyn)->cksum + + rte_cpu_to_be_16(0x0100); + chksum += chksum >= 0xffff; + ip0->hdr_checksum = chksum; + ip0->time_to_live = node_mbuf_priv1(mbuf0, dyn)->ttl - 1; + } + if (unlikely(next_index ^ pvar.next0)) { /* Copy things successfully speculated till now */ rte_memcpy(to_next, from, last_spec * sizeof(from[0])); from += last_spec; @@ -233,13 +470,15 @@ ip4_rewrite_node_process(struct rte_graph *graph, struct rte_node *node, held += last_spec; last_spec = 0; - rte_node_enqueue_x1(graph, node, next0, from[0]); + rte_node_enqueue_x1(graph, node, pvar.next0, from[0]); from += 1; } else { last_spec += 1; } } + IP4_REWRITE_NODE_LAST_TX(node->ctx) = pvar.last_tx_interface; + /* !!! Home run !!! */ if (likely(last_spec == nb_objs)) { rte_node_next_stream_move(graph, node, next_index); @@ -255,22 +494,78 @@ ip4_rewrite_node_process(struct rte_graph *graph, struct rte_node *node, return nb_objs; } +static uint16_t +ip4_rewrite_feature_node_process(struct rte_graph *graph, struct rte_node *node, + void **objs, uint16_t nb_objs) +{ + struct rte_graph_feature_arc *arc = + rte_graph_feature_arc_get(IP4_REWRITE_NODE_OUTPUT_FEATURE_ARC(node->ctx)); + const int dyn = IP4_REWRITE_NODE_PRIV1_OFF(node->ctx); + rte_graph_feature_rt_list_t flist; + + /* If any feature is enabled on this arc */ + if (unlikely(rte_graph_feature_arc_has_any_feature(arc, &flist))) { + if (flist) + return __ip4_rewrite_node_process(graph, node, objs, nb_objs, + dyn, + 1 /* check features */, arc, + (rte_graph_feature_rt_list_t)1); + else + return __ip4_rewrite_node_process(graph, node, objs, nb_objs, + dyn, + 1 /* check features */, arc, + (rte_graph_feature_rt_list_t)0); + } else { + return __ip4_rewrite_node_process(graph, node, objs, nb_objs, dyn, + 0/* don't check features*/, NULL, + 0/* don't care */); + } + return 0; +} + +static uint16_t +ip4_rewrite_node_process(struct rte_graph *graph, struct rte_node *node, + void **objs, uint16_t nb_objs) +{ + const int dyn = IP4_REWRITE_NODE_PRIV1_OFF(node->ctx); + + return __ip4_rewrite_node_process(graph, node, objs, nb_objs, dyn, + 0/* don't check features*/, NULL, + 0/* don't care */); +} + static int ip4_rewrite_node_init(const struct rte_graph *graph, struct rte_node *node) { + rte_graph_feature_arc_t feature_arc = RTE_GRAPH_FEATURE_ARC_INITIALIZER; static bool init_once; RTE_SET_USED(graph); RTE_BUILD_BUG_ON(sizeof(struct ip4_rewrite_node_ctx) > RTE_NODE_CTX_SZ); + RTE_BUILD_BUG_ON(sizeof(struct ip4_rewrite_nh_header) != RTE_CACHE_LINE_SIZE); if (!init_once) { node_mbuf_priv1_dynfield_offset = rte_mbuf_dynfield_register( &node_mbuf_priv1_dynfield_desc); if (node_mbuf_priv1_dynfield_offset < 0) return -rte_errno; - init_once = true; + + /* Create ipv4-output feature arc, if not created + */ + if (rte_graph_feature_arc_lookup_by_name(RTE_IP4_OUTPUT_FEATURE_ARC_NAME, + NULL) < 0) { + if (rte_graph_feature_arc_create(RTE_IP4_OUTPUT_FEATURE_ARC_NAME, + RTE_GRAPH_FEATURE_MAX_PER_ARC, + RTE_MAX_ETHPORTS, + ip4_rewrite_node_get(), &feature_arc)) { + return -rte_errno; + } + init_once = true; + } } IP4_REWRITE_NODE_PRIV1_OFF(node->ctx) = node_mbuf_priv1_dynfield_offset; + IP4_REWRITE_NODE_OUTPUT_FEATURE_ARC(node->ctx) = feature_arc; + IP4_REWRITE_NODE_LAST_TX(node->ctx) = UINT16_MAX; node_dbg("ip4_rewrite", "Initialized ip4_rewrite node initialized"); @@ -329,6 +624,7 @@ rte_node_ip4_rewrite_add(uint16_t next_hop, uint8_t *rewrite_data, static struct rte_node_register ip4_rewrite_node = { .process = ip4_rewrite_node_process, + .feat_arc_proc = ip4_rewrite_feature_node_process, .name = "ip4_rewrite", /* Default edge i.e '0' is pkt drop */ .nb_edges = 1, diff --git a/lib/node/ip4_rewrite_priv.h b/lib/node/ip4_rewrite_priv.h index 5105ec1d29..52f39601bd 100644 --- a/lib/node/ip4_rewrite_priv.h +++ b/lib/node/ip4_rewrite_priv.h @@ -5,9 +5,11 @@ #define __INCLUDE_IP4_REWRITE_PRIV_H__ #include +#include #define RTE_GRAPH_IP4_REWRITE_MAX_NH 64 -#define RTE_GRAPH_IP4_REWRITE_MAX_LEN 56 +#define RTE_GRAPH_IP4_REWRITE_MAX_LEN (sizeof(struct rte_ether_hdr) + \ + (2 * sizeof(struct rte_vlan_hdr))) /** * @internal @@ -15,11 +17,9 @@ * Ipv4 rewrite next hop header data structure. Used to store port specific * rewrite data. */ -struct ip4_rewrite_nh_header { - uint16_t rewrite_len; /**< Header rewrite length. */ +struct __rte_cache_aligned ip4_rewrite_nh_header { uint16_t tx_node; /**< Tx node next index identifier. */ - uint16_t enabled; /**< NH enable flag */ - uint16_t rsvd; + uint16_t rewrite_len; /**< Header rewrite length. */ union { struct { struct rte_ether_addr dst; @@ -30,8 +30,13 @@ struct ip4_rewrite_nh_header { uint8_t rewrite_data[RTE_GRAPH_IP4_REWRITE_MAX_LEN]; /**< Generic rewrite data */ }; + /* used in control path */ + uint8_t enabled; /**< NH enable flag */ }; +_Static_assert(sizeof(struct ip4_rewrite_nh_header) <= (size_t)RTE_CACHE_LINE_SIZE, + "ip4_rewrite_nh_header size must be less or equal to cache line"); + /** * @internal * diff --git a/lib/node/node_private.h b/lib/node/node_private.h index 1de7306792..25db04a9a6 100644 --- a/lib/node/node_private.h +++ b/lib/node/node_private.h @@ -12,6 +12,9 @@ #include #include +#include +#include + extern int rte_node_logtype; #define RTE_LOGTYPE_NODE rte_node_logtype @@ -29,15 +32,28 @@ extern int rte_node_logtype; */ struct node_mbuf_priv1 { union { - /* IP4/IP6 rewrite */ + /** + * IP4/IP6 rewrite + * only used to pass lookup data from + * ip4-lookup to ip4-rewrite + */ struct { uint16_t nh; uint16_t ttl; uint32_t cksum; }; - uint64_t u; }; + /** + * Feature arc data + */ + struct { + /** interface index */ + uint16_t if_index; + /** feature that current mbuf holds */ + rte_graph_feature_t current_feature; + uint8_t rsvd; + }; }; static const struct rte_mbuf_dynfield node_mbuf_priv1_dynfield_desc = { diff --git a/lib/node/rte_node_ip4_api.h b/lib/node/rte_node_ip4_api.h index 950751a525..da4995662a 100644 --- a/lib/node/rte_node_ip4_api.h +++ b/lib/node/rte_node_ip4_api.h @@ -19,6 +19,7 @@ #include #include +#include #ifdef __cplusplus extern "C" { @@ -67,6 +68,8 @@ struct rte_node_ip4_reassembly_cfg { /**< Node identifier to configure. */ }; +#define RTE_IP4_OUTPUT_FEATURE_ARC_NAME "ipv4-output" + /** * Add ipv4 route to lookup table. * From patchwork Thu Oct 10 13:31:05 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Nitin Saxena X-Patchwork-Id: 145605 X-Patchwork-Delegate: thomas@monjalon.net Return-Path: X-Original-To: patchwork@inbox.dpdk.org Delivered-To: patchwork@inbox.dpdk.org Received: from mails.dpdk.org (mails.dpdk.org [217.70.189.124]) by inbox.dpdk.org (Postfix) with ESMTP id BEB7D45B04; Thu, 10 Oct 2024 15:32:05 +0200 (CEST) Received: from mails.dpdk.org (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id 5DA874066A; Thu, 10 Oct 2024 15:31:40 +0200 (CEST) Received: from mx0a-0016f401.pphosted.com (mx0a-0016f401.pphosted.com [67.231.148.174]) by mails.dpdk.org (Postfix) with ESMTP id B7FCE4064F for ; Thu, 10 Oct 2024 15:31:36 +0200 (CEST) Received: from pps.filterd (m0431384.ppops.net [127.0.0.1]) by mx0a-0016f401.pphosted.com (8.18.1.2/8.18.1.2) with ESMTP id 49A9mBhi025242; Thu, 10 Oct 2024 06:31:33 -0700 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=marvell.com; h= cc:content-transfer-encoding:content-type:date:from:in-reply-to :message-id:mime-version:references:subject:to; s=pfpt0220; bh=N Zeop4YgdOHG/1I1Mgey2NMuUAl/F9HIyY3SgCWl8GE=; b=E3GaRazatE4/ItCuK Z/KlpBzM9PsxE9adioDc9IKW2ersXxqutExBXFdWEP+5SwtPyiJ3jWRZXquD6H6W WPwxYUcPDxjSagyu8p2FqoZkwbf/JoQyFelIFXJQJJETn28b+g83haP5E9ECTiRj PmPdwFx5CmzjQV9h157AITpyg1iIcOR4PHMAccPcr8C6Yax/QQ/OD36W5J4t44c5 VciVvItF4bzIS8EeJrdVfVq6HsRWTt8j/HTR8JHqjBeZD8L62VEv6gp02KI3zlCz W1OazIQ0vNWqTsIWHqy46547P79ZukDslEml6YnH3xfpULOGTEgeWOhQnHPmP24J k2qsQ== Received: from dc6wp-exch02.marvell.com ([4.21.29.225]) by mx0a-0016f401.pphosted.com (PPS) with ESMTPS id 426ckmgbhx-2 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Thu, 10 Oct 2024 06:31:31 -0700 (PDT) Received: from DC6WP-EXCH02.marvell.com (10.76.176.209) by DC6WP-EXCH02.marvell.com (10.76.176.209) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.2.1544.4; Thu, 10 Oct 2024 06:31:27 -0700 Received: from maili.marvell.com (10.69.176.80) by DC6WP-EXCH02.marvell.com (10.76.176.209) with Microsoft SMTP Server id 15.2.1544.4 via Frontend Transport; Thu, 10 Oct 2024 06:31:27 -0700 Received: from cavium-PowerEdge-R640.. (unknown [10.28.36.207]) by maili.marvell.com (Postfix) with ESMTP id 9EFA23F7051; Thu, 10 Oct 2024 06:31:24 -0700 (PDT) From: Nitin Saxena To: Jerin Jacob , Kiran Kumar K , Nithin Dabilpuram , Zhirun Yan , Robin Jarry , Christophe Fontaine CC: , Nitin Saxena Subject: [PATCH v4 4/5] test/graph_feature_arc: add functional tests Date: Thu, 10 Oct 2024 19:01:05 +0530 Message-ID: <20241010133111.2764712-5-nsaxena@marvell.com> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20241010133111.2764712-1-nsaxena@marvell.com> References: <20241009133009.1152321-1-nsaxena@marvell.com> <20241010133111.2764712-1-nsaxena@marvell.com> MIME-Version: 1.0 X-Proofpoint-ORIG-GUID: YidbiTQxxkN3Zz2TbjhNR7snsAaQB2yV X-Proofpoint-GUID: YidbiTQxxkN3Zz2TbjhNR7snsAaQB2yV X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.293,Aquarius:18.0.687,Hydra:6.0.235,FMLib:17.0.607.475 definitions=2020-10-13_15,2020-10-13_02,2020-04-07_01 X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org 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 --- app/test/meson.build | 1 + app/test/test_graph_feature_arc.c | 1410 +++++++++++++++++++++++++++++ 2 files changed, 1411 insertions(+) create mode 100644 app/test/test_graph_feature_arc.c diff --git a/app/test/meson.build b/app/test/meson.build index e29258e6ec..740fa1bfb4 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..58b676e215 --- /dev/null +++ b/app/test/test_graph_feature_arc.c @@ -0,0 +1,1410 @@ +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright(C) 2024 Marvell International Ltd. + */ + +#include "test.h" + +#include +#include +#include +#include +#include +#include +#include + +#include + +#ifndef RTE_EXEC_ENV_WINDOWS +#include +#include +#include +#include +#include +#include +#include + +#define MBUFF_SIZE 512 +#define TEST_ARC1_NAME "arc1" +#define TEST_ARC2_NAME "arc2" +#define MAX_INDEXES 10 +#define MAX_FEATURES 5 + +#define SOURCE1 "test_node_arc_source1" +#define INPUT_STATIC "test_node_arc_input_static" +#define OUTPUT_STATIC "test_node_arc_output_static" +#define PKT_FREE_STATIC "test_node_arc_pkt_free_static" +#define ARC1_FEATURE1 "test_node_arc1_feature1" +#define ARC1_FEATURE2 "test_node_arc1_feature2" +#define ARC2_FEATURE1 "test_node_arc2_feature1" +#define ARC2_FEATURE2 "test_node_arc2_feature2" +#define ARC2_FEATURE3 "test_node_arc2_feature3" +#define DUMMY1_STATIC "test_node_arc_dummy1_static" +#define DUMMY2_STATIC "test_node_arc_dummy2_static" + +/* (Node index, Node Name, feature user data 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 +}; + +#define MAX_NODES RTE_DIM(node_names_feature_arc) + +/* 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_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_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_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_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_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_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_node_init(const struct rte_graph *graph, struct rte_node *node); + +typedef struct test_node_priv { + /* index from 0 - MAX_NODES -1 */ + uint8_t node_index; + + /* feature */ + rte_graph_feature_t feature; + + /* 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; + +static int graph_dynfield_offset = -1; +static rte_graph_feature_arc_t arcs[RTE_GRAPH_FEATURE_ARC_MAX + 128]; +static struct rte_mbuf mbuf[MAX_NODES + 1][MBUFF_SIZE]; +static void *mbuf_p[MAX_NODES + 1][MBUFF_SIZE]; +static rte_graph_t graph_id = RTE_GRAPH_ID_INVALID; + +const char *node_patterns_feature_arc[] = { + "test_node_arc*" +}; + +static int32_t +compute_unique_user_data(const char *parent, const char *child, uint32_t interface_index) +{ + uint32_t user_data = interface_index; + + RTE_SET_USED(parent); +#define R(idx, node, node_cookie) { \ + if (!strcmp(child, node)) { \ + user_data += node_cookie; \ + } \ + } + + FOREACH_TEST_NODE_ARC +#undef R + + return user_data; +} + +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_node_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->feature = RTE_GRAPH_FEATURE_INVALID; + priv->arc = RTE_GRAPH_FEATURE_ARC_INITIALIZER; + +#define R(idx, _name, user_data) { \ + if (!strcmp(node->name, _name)) { \ + priv->node_index = idx; \ + } \ + } + FOREACH_TEST_NODE_ARC +#undef R + + return 0; +} + +uint16_t +source1_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 source1 = { + .name = SOURCE1, + .process = source1_fn, + .flags = RTE_NODE_SOURCE_F, + .nb_edges = 3, + .init = common_node_init, + .next_nodes = {INPUT_STATIC, DUMMY1_STATIC, DUMMY2_STATIC}, +}; +RTE_NODE_REGISTER(source1); + +uint16_t +input_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; +} + +uint16_t +input_fa_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 input = { + .name = INPUT_STATIC, + .process = input_fn, + .feat_arc_proc = input_fa_fn, + .nb_edges = 2, + .init = common_node_init, + .next_nodes = {OUTPUT_STATIC, DUMMY1_STATIC}, +}; +RTE_NODE_REGISTER(input); + +uint16_t +output_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; +} + +uint16_t +output_fa_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 output = { + .name = OUTPUT_STATIC, + .process = output_fn, + .feat_arc_proc = output_fa_fn, + .nb_edges = 3, + .init = common_node_init, + .next_nodes = {DUMMY1_STATIC, PKT_FREE_STATIC, DUMMY2_STATIC}, +}; +RTE_NODE_REGISTER(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); + return 0; +} + +uint16_t +pkt_free_fa_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 pkt_free = { + .name = PKT_FREE_STATIC, + .process = pkt_free_fn, + .feat_arc_proc = pkt_free_fa_fn, + .nb_edges = 1, + .init = common_node_init, + .next_nodes = {DUMMY1_STATIC}, +}; +RTE_NODE_REGISTER(pkt_free); + +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_node_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_node_init, + .next_nodes = { ARC1_FEATURE1, ARC1_FEATURE2, ARC2_FEATURE1, + ARC2_FEATURE2, ARC2_FEATURE3}, +}; +RTE_NODE_REGISTER(dummy2); + +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); + + return 0; +} + +uint16_t +arc1_feature1_fa_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 arc1_feature1 = { + .name = ARC1_FEATURE1, + .process = arc1_feature1_fn, + .feat_arc_proc = arc1_feature1_fa_fn, + .nb_edges = 0, + .init = common_node_init, +}; +RTE_NODE_REGISTER(arc1_feature1); + +uint16_t +arc1_feature2_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; +} + +uint16_t +arc1_feature2_fa_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 arc1_feature2 = { + .name = ARC1_FEATURE2, + .process = arc1_feature2_fn, + .feat_arc_proc = arc1_feature2_fa_fn, + .nb_edges = 0, + .init = common_node_init, +}; +RTE_NODE_REGISTER(arc1_feature2); + +uint16_t +arc2_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); + + return 0; +} + +uint16_t +arc2_feature1_fa_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 arc2_feature1 = { + .name = ARC2_FEATURE1, + .process = arc2_feature1_fn, + .feat_arc_proc = arc2_feature1_fa_fn, + .nb_edges = 0, + .init = common_node_init, +}; +RTE_NODE_REGISTER(arc2_feature1); + +uint16_t +arc2_feature2_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; +} + +uint16_t +arc2_feature2_fa_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 arc2_feature2 = { + .name = ARC2_FEATURE2, + .process = arc2_feature2_fn, + .feat_arc_proc = arc2_feature2_fa_fn, + .nb_edges = 0, + .init = common_node_init, +}; +RTE_NODE_REGISTER(arc2_feature2); + +uint16_t +arc2_feature3_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; +} + +uint16_t +arc2_feature3_fa_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 arc2_feature3 = { + .name = ARC2_FEATURE3, + .process = arc2_feature3_fn, + .feat_arc_proc = arc2_feature3_fa_fn, + .nb_edges = 0, + .init = common_node_init, +}; +RTE_NODE_REGISTER(arc2_feature3); + +static int +create_graph(void) +{ + struct rte_graph_param gconf = { + .socket_id = SOCKET_ID_ANY, + .nb_node_patterns = 1, + .node_patterns = node_patterns_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 +__test_create_feature_arc(rte_graph_feature_arc_t *arcs, int max_arcs) +{ + rte_graph_feature_arc_t arc; + const char *sample_arc_name = "sample_arc"; + char arc_name[256]; + int n_arcs; + + /* Create max number of feature arcs first */ + for (n_arcs = 0; n_arcs < max_arcs; n_arcs++) { + snprintf(arc_name, sizeof(arc_name), "%s-%u", sample_arc_name, n_arcs); + if (rte_graph_feature_arc_create(arc_name, MAX_FEATURES, + MAX_INDEXES, &dummy1, &arcs[n_arcs])) { + printf("Feature arc creation failed for %u\n", n_arcs); + return TEST_FAILED; + } + } + /* Verify feature arc created more than max_arcs must fail */ + if (!rte_graph_feature_arc_create("negative_test_create_arc", MAX_FEATURES, + MAX_INDEXES, &dummy2, &arc)) { + printf("Feature arc creation success for more than max configured: %u\n", n_arcs); + return TEST_FAILED; + } + /* Make sure lookup passes for all feature arcs */ + 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)) { + if (arc != arcs[n_arcs]) { + printf("%s: Feature arc lookup mismatch for arc [%p, exp: %p]\n", + arc_name, (void *)arc, (void *)arcs[n_arcs]); + return TEST_FAILED; + } + } 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, i; + + /* Create arcs with RTE_GRAPH_FEATURE_ARC_MAX */ + ret = __test_create_feature_arc(arcs, RTE_GRAPH_FEATURE_ARC_MAX); + if (ret) { + printf("Feature arc creation test failed for RTE_GRAPH_FEATURE_ARC_MAX arcs\n"); + return TEST_FAILED; + } + /* destroy all arcs via cleanup API*/ + ret = rte_graph_feature_arc_cleanup(); + if (ret) { + printf("Feature arc cleanup failed\n"); + return TEST_FAILED; + } + +#define NUM_FEAT_ARCS 128 + /* create 128 dummy feature arcs */ + ret = rte_graph_feature_arc_init(NUM_FEAT_ARCS); + if (ret) { + printf("Feature arc init failed for NUM_FEAT_ARCS"); + return TEST_FAILED; + } + ret = __test_create_feature_arc(arcs, NUM_FEAT_ARCS); + if (ret) { + printf("Feature arc creation test failed for NUM_FEAT_ARCS\n"); + return TEST_FAILED; + } + /* destroy all of them*/ + for (i = 0; i < NUM_FEAT_ARCS; i++) { + if (rte_graph_feature_arc_destroy(arcs[i])) { + printf("Feature arc destroy failed for %u\n", i); + return TEST_FAILED; + } + } + rte_graph_feature_arc_cleanup(); + + /* Create two arcs as per test plan */ + /* First arc start/source node is node: SOURCE1 */ + if (rte_graph_feature_arc_create(TEST_ARC1_NAME, MAX_FEATURES, + MAX_INDEXES, &source1, &arcs[0])) { + printf("Feature arc creation failed for %s\n", TEST_ARC1_NAME); + return TEST_FAILED; + } + + /* Duplicate name should fail */ + if (!rte_graph_feature_arc_create(TEST_ARC1_NAME, MAX_FEATURES, + MAX_INDEXES, &source1, &arcs[1])) { + printf("Duplicate feature arc %s creation is not caught\n", TEST_ARC1_NAME); + return TEST_FAILED; + } + /* Second arc start/source node is node: OUTPUT_STATIC */ + if (rte_graph_feature_arc_create(TEST_ARC2_NAME, MAX_FEATURES, + MAX_INDEXES, &output, &arcs[1])) { + printf("Feature arc creation failed for %s\n", TEST_ARC1_NAME); + return TEST_FAILED; + } + return TEST_SUCCESS; +} + +static int +test_graph_feature_arc_features_add(void) +{ + rte_graph_feature_t temp; + + /* First feature to SOURCE1 start node -> ARC1_FEATURE1 */ + if (rte_graph_feature_add(arcs[0], &arc1_feature1, NULL, NULL)) { + printf("%s: Feature add failed for adding feature %s\n", + TEST_ARC1_NAME, ARC1_FEATURE1); + return TEST_FAILED; + } + /* Second feature to SOURCE1 -> ARC1_FEATURE2 */ + if (rte_graph_feature_add(arcs[0], &arc1_feature2, NULL, NULL)) { + printf("%s: Feature add failed for adding feature %s\n", + TEST_ARC1_NAME, ARC1_FEATURE2); + return TEST_FAILED; + } + /* adding statically connected INPUT_STATIC as a last feature */ + if (rte_graph_feature_add(arcs[0], &input, ARC1_FEATURE2, NULL)) { + printf("%s: Feature add failed for adding feature %s after %s\n", + TEST_ARC1_NAME, INPUT_STATIC, ARC1_FEATURE2); + return TEST_FAILED; + } + /* First feature to OUTPUT_STATIC start node -> ARC2_FEATURE3 */ + if (rte_graph_feature_add(arcs[1], &arc2_feature3, NULL, NULL)) { + printf("%s: Feature add failed for adding feature %s\n", + TEST_ARC2_NAME, ARC2_FEATURE3); + return TEST_FAILED; + } + /* Second feature to OUTPUT_STATIC -> ARC2_FEATURE1 and before feature to + * ARC2_FEATURE3 + */ + if (rte_graph_feature_add(arcs[1], &arc2_feature1, NULL, ARC2_FEATURE3)) { + printf("%s: Feature add failed for adding feature %s after %s\n", + TEST_ARC2_NAME, ARC2_FEATURE3, ARC2_FEATURE1); + return TEST_FAILED; + } + /* Add PKT_FREE node as last feature, next to arc2_feature3 */ + if (rte_graph_feature_add(arcs[1], &pkt_free, ARC2_FEATURE3, NULL)) { + printf("%s: Feature add failed for adding feature %s after %s\n", + TEST_ARC2_NAME, PKT_FREE_STATIC, ARC2_FEATURE3); + return TEST_FAILED; + } + /* Adding feature ARC2_FEATURE2 between ARC2_FEATURE1 and ARC2_FEATURE3. */ + if (rte_graph_feature_add(arcs[1], &arc2_feature2, ARC2_FEATURE1, ARC2_FEATURE3)) { + printf("%s: Feature add failed for adding feature %s between [%s - %s]\n", + TEST_ARC2_NAME, ARC2_FEATURE2, ARC2_FEATURE1, ARC2_FEATURE3); + return TEST_FAILED; + } + /* Now check feature sequencing is correct for both ARCS */ + + /* arc1_feature1 must be first feature to arcs[0] */ + if (!strstr(ARC1_FEATURE1, + rte_graph_feature_arc_feature_to_name(arcs[0], + rte_graph_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], rte_graph_feature_cast(0))); + return TEST_FAILED; + } + + /* arc1_feature2 must be second feature to arcs[0] */ + if (!strstr(ARC1_FEATURE2, + rte_graph_feature_arc_feature_to_name(arcs[0], + rte_graph_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], rte_graph_feature_cast(1))); + return 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 - rte_graph_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 - rte_graph_feature_cast(1))); + return TEST_FAILED; + } + + /* arc2_feature1 must be first feature to arcs[1] */ + if (!strstr(ARC2_FEATURE1, + rte_graph_feature_arc_feature_to_name(arcs[1], + rte_graph_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], rte_graph_feature_cast(0))); + return TEST_FAILED; + } + + /* arc2_feature2 must be second feature to arcs[1] */ + if (!strstr(ARC2_FEATURE2, + rte_graph_feature_arc_feature_to_name(arcs[1], + rte_graph_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], rte_graph_feature_cast(1))); + return TEST_FAILED; + } + + /* arc2_feature3 must be third feature to arcs[1] */ + if (!strstr(ARC2_FEATURE3, + rte_graph_feature_arc_feature_to_name(arcs[1], + rte_graph_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], rte_graph_feature_cast(2))); + return 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 - rte_graph_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 - rte_graph_feature_cast(1))); + return TEST_FAILED; + } + + if (get_edge(&arc2_feature1, &pkt_free, NULL)) { + printf("%s: Edge not found between %s and %s\n", + TEST_ARC2_NAME, ARC2_FEATURE1, PKT_FREE_STATIC); + return TEST_FAILED; + } + + return create_graph(); +} + +static int +test_graph_feature_arc_first_feature_enable(void) +{ + uint32_t n_indexes, n_features, count = 0; + rte_graph_feature_rt_list_t feature_list, temp = 0; + struct rte_node_register *parent, *child; + rte_graph_feature_data_t *fdata = NULL; + struct rte_graph_feature_arc *arc; + rte_graph_feature_t feature; + char *feature_name = NULL; + int32_t user_data; + rte_edge_t edge = ~0; + + arc = rte_graph_feature_arc_get(arcs[0]); + + if (rte_graph_feature_arc_has_any_feature(arc, &feature_list)) { + 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 < MAX_INDEXES; n_indexes++) { + n_features = n_indexes % 3 /* 3 features added to arc1 */; + feature_name = rte_graph_feature_arc_feature_to_name(arcs[0], n_features); + user_data = compute_unique_user_data(arc->start_node->name, feature_name, + n_indexes); + if (rte_graph_feature_validate(arcs[0], n_indexes, feature_name, 1, true)) { + printf("%s: Feature validate failed for %s on index %u\n", + TEST_ARC1_NAME, feature_name, n_indexes); + return TEST_FAILED; + } + /* negative test case. enable feature on invalid index */ + if (!n_indexes && !rte_graph_feature_enable(arcs[0], MAX_INDEXES, feature_name, + (int32_t)user_data)) { + 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, + (int32_t)user_data)) { + printf("%s: Feature enable failed for %s on index %u\n", + TEST_ARC1_NAME, feature_name, n_indexes); + return TEST_FAILED; + } + /* has any feature should be valid */ + if (!rte_graph_feature_arc_has_any_feature(arc, &feature_list)) { + printf("%s: Feature arc should have any_feature enabled by now\n", + TEST_ARC1_NAME); + return TEST_FAILED; + } + if (temp == feature_list) { + printf("%s: Activer feature list not switched from %u -> %u\n", + TEST_ARC1_NAME, temp, feature_list); + return TEST_FAILED; + } + temp = feature_list; + 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++; + } + if (!rte_graph_feature_arc_has_any_feature(arc, &feature_list)) { + printf("%s: Feature arc should have any_feature enabled by now\n", + TEST_ARC1_NAME); + return TEST_FAILED; + } + /* 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)) { + 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)) { + 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 < MAX_INDEXES; n_indexes++) { + if (!rte_graph_feature_arc_first_feature_get(arc, feature_list, n_indexes, + &feature)) { + printf("%s: No first feature enabled on index: %u\n", + TEST_ARC1_NAME, n_indexes); + return TEST_FAILED; + } + /* Get first feature data and ensure edge and user_data are correct */ + fdata = rte_graph_feature_data_get(arc, rte_graph_feature_get(arc, feature), + n_indexes); + parent = arc->start_node; + if (0 == (n_indexes % 3)) + child = &arc1_feature1; + else if (1 == (n_indexes % 3)) + child = &arc1_feature2; + else + child = &input; + + if (get_edge(parent, child, &edge)) { + printf("%s: Edge not found between %s and %s\n", + TEST_ARC1_NAME, parent->name, child->name); + return TEST_FAILED; + } + if (fdata->next_edge != edge) { + printf("%s: Edge mismatch for first feature on index %u [%u, exp: %u]\n", + TEST_ARC1_NAME, n_indexes, fdata->next_edge, edge); + return TEST_FAILED; + } + if (fdata->user_data != compute_unique_user_data(parent->name, child->name, + n_indexes)) { + printf("%s: First feature user data mismatch on index %u [%u, exp: %u]\n", + TEST_ARC1_NAME, n_indexes, fdata->user_data, + compute_unique_user_data(parent->name, child->name, n_indexes)); + return TEST_FAILED; + } + } + return TEST_SUCCESS; +} + +static int +verify_feature_sequencing(struct rte_graph_feature_arc *arc) +{ + rte_graph_feature_rt_list_t feature_list; + struct rte_node_register *parent, *child; + rte_graph_feature_data_t *fdata = NULL; + rte_graph_feature_t feature; + uint32_t n_indexes; + rte_edge_t edge = ~0; + int32_t user_data; + + if (!rte_graph_feature_arc_has_any_feature(arc, &feature_list)) { + printf("%s: feature_list can't be obtained\n", + arc->feature_arc_name); + return TEST_FAILED; + } + /* Verify next features on interface 0 and interface 1*/ + for (n_indexes = 0; n_indexes < 2; n_indexes++) { + if (!rte_graph_feature_arc_first_feature_get(arc, feature_list, n_indexes, + &feature)) { + printf("%s: No first feature enabled on index: 0\n", + arc->feature_arc_name); + return TEST_FAILED; + } + parent = arc->start_node; + child = rte_graph_feature_arc_feature_to_node(arcs[1], feature); + /* until fast path API reaches last feature i.e pkt_free */ + while (child != &pkt_free) { + fdata = rte_graph_feature_data_get(arc, + rte_graph_feature_get(arc, feature), + n_indexes); + + if (get_edge(parent, child, &edge)) { + printf("%s: Edge not found between %s and %s\n", + arc->feature_arc_name, parent->name, child->name); + return TEST_FAILED; + } + user_data = compute_unique_user_data(parent->name, child->name, n_indexes); + if (fdata->next_edge != edge) { + printf("%s: Edge mismatch for %s->%s on index %u [%u, exp: %u]\n", + arc->feature_arc_name, parent->name, child->name, n_indexes, + fdata->next_edge, edge); + return TEST_FAILED; + } + if (fdata->user_data != user_data) { + printf("%s: Udata mismatch for %s->%s on index %u [%u, exp: %u]\n", + arc->feature_arc_name, parent->name, child->name, n_indexes, + fdata->user_data, user_data); + return TEST_FAILED; + } + + feature = fdata->next_enabled_feature; + + parent = child; + child = rte_graph_feature_arc_feature_to_node(arcs[1], + fdata->next_enabled_feature); + } + } + return TEST_SUCCESS; +} + +static int +test_graph_feature_arc_next_feature_enable(void) +{ + rte_graph_feature_rt_list_t feature_list; + struct rte_node_register *parent, *child; + rte_graph_feature_data_t *fdata = NULL; + struct rte_graph_feature_arc *arc; + uint32_t n_indexes, n_features; + rte_graph_feature_t feature; + char *feature_name = NULL; + rte_edge_t edge = ~0; + int32_t user_data; + + arc = rte_graph_feature_arc_get(arcs[1]); + + if (rte_graph_feature_arc_has_any_feature(arc, &feature_list)) { + printf("%s: Feature arc should not have any feature enabled by now\n", + TEST_ARC2_NAME); + return TEST_FAILED; + } + + if (rte_graph_feature_arc_num_enabled_features(arcs[1])) { + printf("%s: Feature arc should not have any_feature() enabled by now\n", + TEST_ARC2_NAME); + return TEST_FAILED; + } + /* + * On interface 0, enable feature 2, skip feature 1 for later + * On interface 1, enable feature 3 + * On interface 2, enable pkt_free feature + * On interface 3, continue as interface 0 + * + * later enable next feature sequence for interface 0 from feature2 -> pkt_free + * later enable next feature sequence for interface 1 from feature3 -> pkt_free + * + * also later enable feature-1 and see first feature changes for all indexes + */ + for (n_indexes = 0; n_indexes < MAX_INDEXES; n_indexes++) { + n_features = (n_indexes % 3) + 1; /* feature2 to pkt_free are 3 features */ + feature_name = rte_graph_feature_arc_feature_to_name(arcs[1], n_features); + 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, + (int32_t)user_data)) { + printf("%s: Feature enable failed for %s on index %u\n", + TEST_ARC2_NAME, feature_name, n_indexes); + return TEST_FAILED; + } + /* has any feature should be valid */ + if (!rte_graph_feature_arc_has_any_feature(arc, &feature_list)) { + printf("%s: Feature arc should have any_feature enabled by now\n", + TEST_ARC2_NAME); + return TEST_FAILED; + } + } + /* Retrieve latest feature_list */ + rte_graph_feature_arc_has_any_feature(arc, &feature_list); + /* verify first feature */ + for (n_indexes = 0; n_indexes < MAX_INDEXES; n_indexes++) { + if (!rte_graph_feature_arc_first_feature_get(arc, feature_list, n_indexes, + &feature)) { + printf("%s: No first feature enabled on index: %u\n", + TEST_ARC2_NAME, n_indexes); + return TEST_FAILED; + } + /* Get first feature data and ensure edge and user_data are correct */ + fdata = rte_graph_feature_data_get(arc, rte_graph_feature_get(arc, feature), + n_indexes); + parent = arc->start_node; + if (0 == (n_indexes % 3)) + child = &arc2_feature2; + else if (1 == (n_indexes % 3)) + child = &arc2_feature3; + else + child = &pkt_free; + + if (get_edge(parent, child, &edge)) { + printf("%s: Edge not found between %s and %s\n", + TEST_ARC2_NAME, parent->name, child->name); + return TEST_FAILED; + } + if (fdata->next_edge != edge) { + printf("%s: Edge mismatch for first feature on index %u [%u, exp: %u]\n", + TEST_ARC2_NAME, n_indexes, fdata->next_edge, edge); + return TEST_FAILED; + } + if (fdata->user_data != compute_unique_user_data(parent->name, child->name, + n_indexes)) { + printf("%s: First feature user data mismatch on index %u [%u, exp: %u]\n", + TEST_ARC2_NAME, n_indexes, fdata->user_data, + compute_unique_user_data(parent->name, child->name, n_indexes)); + return TEST_FAILED; + } + } + /* add next_features now + * On interface 0, enable feature-3 and pkt_free + * On interface 1, enable pkt_free + * Skip interface 2 + * On interface 3, same as interface 0 + * On interface 4, same as interface 1 + */ + for (n_indexes = 0; n_indexes < MAX_INDEXES; n_indexes++) { + if (0 == (n_indexes % 3)) { + if (rte_graph_feature_enable(arcs[1], n_indexes, ARC2_FEATURE3, + compute_unique_user_data(ARC2_FEATURE2, + ARC2_FEATURE3, + n_indexes))) { + printf("%s: Feature enable failed for %s -> (%s) on index %u\n", + TEST_ARC2_NAME, ARC2_FEATURE2, ARC2_FEATURE3, n_indexes); + return TEST_FAILED; + } + } + /* pkt_free on interface-0, 1, 3, 4 and so on */ + if ((0 == (n_indexes % 3)) || (1 == (n_indexes % 3))) { + if (rte_graph_feature_enable(arcs[1], n_indexes, PKT_FREE_STATIC, + compute_unique_user_data(ARC2_FEATURE3, + PKT_FREE_STATIC, + n_indexes))) { + printf("%s: Feature enable failed %s -> (%s) on index %u\n", + TEST_ARC2_NAME, ARC2_FEATURE3, PKT_FREE_STATIC, n_indexes); + return TEST_FAILED; + } + } + } + + if (verify_feature_sequencing(arc) == TEST_FAILED) + return TEST_FAILED; + + /* Enable feature-1 on all interfaces and check first feature changes */ + for (n_indexes = 0; n_indexes < MAX_INDEXES; n_indexes++) { + user_data = compute_unique_user_data(arc->start_node->name, ARC2_FEATURE1, + n_indexes); + if (rte_graph_feature_enable(arcs[1], n_indexes, ARC2_FEATURE1, + (int32_t)user_data)) { + printf("%s: Feature enable failed for %s on index %u\n", + TEST_ARC2_NAME, feature_name, n_indexes); + return TEST_FAILED; + } + } + rte_graph_feature_arc_has_any_feature(arc, &feature_list); + for (n_indexes = 0; n_indexes < MAX_INDEXES; n_indexes++) { + if (!rte_graph_feature_arc_first_feature_get(arc, feature_list, n_indexes, + &feature)) { + printf("%s: None first feature enabled on index: %u\n", + TEST_ARC2_NAME, n_indexes); + return TEST_FAILED; + } + if (feature != rte_graph_feature_cast(0)) { + printf("%s: First feature mismatch on index %u [%u, exp: %u]\n", + TEST_ARC2_NAME, n_indexes, feature, rte_graph_feature_cast(0)); + return TEST_FAILED; + } + } + if (verify_feature_sequencing(arc) == TEST_FAILED) + return TEST_FAILED; + + return TEST_SUCCESS; +} + +static int +test_graph_feature_arc_first_feature_disable(void) +{ + rte_graph_feature_rt_list_t feature_list; + struct rte_graph_feature_arc *arc; + rte_graph_feature_t feature; + uint32_t n_indexes; + + arc = rte_graph_feature_arc_get(arcs[1]); + + /* Disable feature-1 on all interfaces and check first feature changes */ + for (n_indexes = 0; n_indexes < MAX_INDEXES; n_indexes++) { + if (rte_graph_feature_disable(arcs[1], n_indexes, ARC2_FEATURE1)) { + printf("%s: Feature disable failed for %s on index %u\n", + TEST_ARC2_NAME, ARC2_FEATURE1, n_indexes); + return TEST_FAILED; + } + } + rte_graph_feature_arc_has_any_feature(arc, &feature_list); + for (n_indexes = 0; n_indexes < MAX_INDEXES; n_indexes++) { + if (!rte_graph_feature_arc_first_feature_get(arc, feature_list, n_indexes, + &feature)) { + printf("%s: First feature get failed on index: %u\n", + TEST_ARC2_NAME, n_indexes); + return TEST_FAILED; + } + if (feature == rte_graph_feature_cast(0)) { + printf("%s: First feature not disabled on index %u [%u, exp: %u]\n", + TEST_ARC2_NAME, n_indexes, feature, rte_graph_feature_cast(1)); + return TEST_FAILED; + } + if (!strncmp(ARC2_FEATURE1, + rte_graph_feature_arc_feature_to_name(arcs[1], feature), + strlen(ARC2_FEATURE1))) { + printf("%s: First feature mismatch on index %u [%s, exp: %s]\n", + TEST_ARC2_NAME, n_indexes, + rte_graph_feature_arc_feature_to_name(arcs[1], feature), + ARC2_FEATURE2); + return TEST_FAILED; + } + } + if (verify_feature_sequencing(arc) == TEST_FAILED) + return TEST_FAILED; + + return TEST_SUCCESS; +} + +static int +test_graph_feature_arc_next_feature_disable(void) +{ + rte_graph_feature_rt_list_t feature_list; + struct rte_graph_feature_arc *arc; + rte_graph_feature_t feature; + uint32_t n_indexes; + + arc = rte_graph_feature_arc_get(arcs[1]); + + /* + * On interface 0, disable feature 2, keep feature3 and pkt_free enabled + * On interface 1, skip interface 1 where feature3 and pkt_free are enabled + * skip interface 2 as only pkt_free is enabled + */ + for (n_indexes = 0; n_indexes < MAX_INDEXES; n_indexes++) { + if (!(n_indexes % 3)) { + if (rte_graph_feature_disable(arcs[1], n_indexes, ARC2_FEATURE2)) { + printf("%s: Feature disable failed for %s on index %u\n", + TEST_ARC2_NAME, ARC2_FEATURE2, n_indexes); + return TEST_FAILED; + } + } + + if (verify_feature_sequencing(arc) == TEST_FAILED) + return TEST_FAILED; + } + + /** + * Disable feature 3 on all interface 0 and 1 and check first feature + * is pkt_free on all indexes + */ + for (n_indexes = 0; n_indexes < MAX_INDEXES; n_indexes++) { + if ((0 == (n_indexes % 3)) || (1 == (n_indexes % 3))) { + if (rte_graph_feature_disable(arcs[1], n_indexes, ARC2_FEATURE3)) { + printf("%s: Feature disable failed for %s on index %u\n", + TEST_ARC2_NAME, ARC2_FEATURE3, n_indexes); + return TEST_FAILED; + } + } + } + /* Make sure pkt_free is first feature for all indexes */ + rte_graph_feature_arc_has_any_feature(arc, &feature_list); + for (n_indexes = 0; n_indexes < MAX_INDEXES; n_indexes++) { + if (!rte_graph_feature_arc_first_feature_get(arc, feature_list, n_indexes, + &feature)) { + printf("%s: First feature get failed on index: %u\n", + TEST_ARC2_NAME, n_indexes); + return TEST_FAILED; + } + if (strncmp(PKT_FREE_STATIC, + rte_graph_feature_arc_feature_to_name(arcs[1], feature), + strlen(PKT_FREE_STATIC))) { + printf("%s: %s is not first feature found on index %u [%s, exp: %s]\n", + TEST_ARC2_NAME, PKT_FREE_STATIC, n_indexes, + rte_graph_feature_arc_feature_to_name(arcs[1], feature), + PKT_FREE_STATIC); + return TEST_FAILED; + } + } + + /* Disable PKT_FREE_STATIC from all indexes with no feature enabled on any interface */ + for (n_indexes = 0; n_indexes < MAX_INDEXES; n_indexes++) { + if (rte_graph_feature_disable(arcs[1], n_indexes, PKT_FREE_STATIC)) { + printf("%s: Feat disable failed for %s on index %u\n", + TEST_ARC2_NAME, PKT_FREE_STATIC, n_indexes); + return TEST_FAILED; + } + } + /* Make sure no feature is enabled now on any interface */ + rte_graph_feature_arc_has_any_feature(arc, &feature_list); + for (n_indexes = 0; n_indexes < MAX_INDEXES; n_indexes++) { + if (rte_graph_feature_arc_first_feature_get(arc, feature_list, n_indexes, + &feature)) { + printf("%s: Index: %u should not have first feature enabled\n", + TEST_ARC2_NAME, n_indexes); + return TEST_FAILED; + } + } + return TEST_SUCCESS; +} + +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 [%p, exp: %p]\n", + TEST_ARC1_NAME, (void *)arc, (void *)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 [%p, exp: %p]\n", + TEST_ARC2_NAME, (void *)arc, (void *)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 int +graph_feature_arc_setup(void) +{ + unsigned long i, j; + + static const struct rte_mbuf_dynfield graph_dynfield_desc = { + .name = "test_graph_dynfield", + .size = sizeof(graph_dynfield_t), + .align = alignof(graph_dynfield_t), + }; + + graph_dynfield_offset = + rte_mbuf_dynfield_register(&graph_dynfield_desc); + if (graph_dynfield_offset < 0) { + printf("Cannot register mbuf field\n"); + return TEST_FAILED; + } + RTE_SET_USED(graph_dynfield_offset); + + for (i = 0; i <= MAX_NODES; i++) { + for (j = 0; j < MBUFF_SIZE; j++) + mbuf_p[i][j] = &mbuf[i][j]; + } + + 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_first_feature_enable), + TEST_CASE(test_graph_feature_arc_next_feature_enable), + TEST_CASE(test_graph_feature_arc_first_feature_disable), + TEST_CASE(test_graph_feature_arc_next_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 */ From patchwork Thu Oct 10 13:31:06 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Nitin Saxena X-Patchwork-Id: 145606 X-Patchwork-Delegate: thomas@monjalon.net Return-Path: X-Original-To: patchwork@inbox.dpdk.org Delivered-To: patchwork@inbox.dpdk.org Received: from mails.dpdk.org (mails.dpdk.org [217.70.189.124]) by inbox.dpdk.org (Postfix) with ESMTP id AA5E345B04; Thu, 10 Oct 2024 15:32:16 +0200 (CEST) Received: from mails.dpdk.org (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id A526340693; Thu, 10 Oct 2024 15:31:42 +0200 (CEST) Received: from mx0b-0016f401.pphosted.com (mx0b-0016f401.pphosted.com [67.231.156.173]) by mails.dpdk.org (Postfix) with ESMTP id 4C97B4066E for ; Thu, 10 Oct 2024 15:31:41 +0200 (CEST) Received: from pps.filterd (m0045851.ppops.net [127.0.0.1]) by mx0b-0016f401.pphosted.com (8.18.1.2/8.18.1.2) with ESMTP id 49A1Msl2009624; Thu, 10 Oct 2024 06:31:36 -0700 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=marvell.com; h= cc:content-transfer-encoding:content-type:date:from:in-reply-to :message-id:mime-version:references:subject:to; s=pfpt0220; bh=j h8wME8iRPdXbeB/DUl+Qy+r2aJ0woP1YQq7pH9z6lE=; b=kE5GgTUKdnzFPo4VR j8enBe2owf8xECOUu40sJYVzmu8QSjTxqSObbmDQZcoPLtp99kz86psYJfvaCv1J yH1u/BHM4K0EERD+rddF+F5Hpn0mv7Y7JB9DqkY7M9KY/hFbZbz9HO/My0yE7+gF oCmcLiktHAzLlXRS5e0EPLT09GUD4pJ7dM9xBx8ak73zpmX6VLfsRhjfsdOn3vtA RpcUCDP78burStFlUlkHDQZp6fJruNzfNkXAHvZeXQ+rua0fyl/xNqmDND74BWyn AvYB0IPL+3XOy+OFCwgBTPBsRsjzavhG9qYzwuqY6sGyuca8QMmd4y58zpiN1Wgd +M2aw== Received: from dc5-exch05.marvell.com ([199.233.59.128]) by mx0b-0016f401.pphosted.com (PPS) with ESMTPS id 4264cj99q6-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Thu, 10 Oct 2024 06:31:33 -0700 (PDT) Received: from DC5-EXCH05.marvell.com (10.69.176.209) by DC5-EXCH05.marvell.com (10.69.176.209) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.2.1544.4; Thu, 10 Oct 2024 06:31:30 -0700 Received: from maili.marvell.com (10.69.176.80) by DC5-EXCH05.marvell.com (10.69.176.209) with Microsoft SMTP Server id 15.2.1544.4 via Frontend Transport; Thu, 10 Oct 2024 06:31:30 -0700 Received: from cavium-PowerEdge-R640.. (unknown [10.28.36.207]) by maili.marvell.com (Postfix) with ESMTP id AA95D3F7068; Thu, 10 Oct 2024 06:31:27 -0700 (PDT) From: Nitin Saxena To: Jerin Jacob , Kiran Kumar K , Nithin Dabilpuram , Zhirun Yan , Robin Jarry , Christophe Fontaine CC: , Nitin Saxena Subject: [PATCH v4 5/5] docs: add programming guide for feature arc Date: Thu, 10 Oct 2024 19:01:06 +0530 Message-ID: <20241010133111.2764712-6-nsaxena@marvell.com> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20241010133111.2764712-1-nsaxena@marvell.com> References: <20241009133009.1152321-1-nsaxena@marvell.com> <20241010133111.2764712-1-nsaxena@marvell.com> MIME-Version: 1.0 X-Proofpoint-GUID: bbjHuIB0IGavR5nGl3-mWOvJwLrdo_jd X-Proofpoint-ORIG-GUID: bbjHuIB0IGavR5nGl3-mWOvJwLrdo_jd X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.293,Aquarius:18.0.1039,Hydra:6.0.680,FMLib:17.12.60.29 definitions=2024-09-06_09,2024-09-06_01,2024-09-02_01 X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org Updated graph library guide with feature arc Signed-off-by: Nitin Saxena --- doc/guides/prog_guide/graph_lib.rst | 288 ++++++++++++++++++++ doc/guides/prog_guide/img/feature_arc-1.png | Bin 0 -> 61532 bytes doc/guides/prog_guide/img/feature_arc-2.png | Bin 0 -> 155806 bytes doc/guides/prog_guide/img/feature_arc-3.png | Bin 0 -> 143697 bytes 4 files changed, 288 insertions(+) create mode 100644 doc/guides/prog_guide/img/feature_arc-1.png create mode 100644 doc/guides/prog_guide/img/feature_arc-2.png create mode 100644 doc/guides/prog_guide/img/feature_arc-3.png new file mode 100644 index 0000000000000000000000000000000000000000..604a67229b29a9c8ace59d28a7324e02c2bc4a89 GIT binary patch literal 155806 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�!fv6yo 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ΐMNRyBlZP4r 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

<*20L*Rn;>%zk*s=|MV9=Yu&K(zR5< z7PS7unmgt66m!YqjPG$AAevhHG&PMxc`98^2l2rxOxP|1W|Efm_gLfa$r%?mht5B+ zc`KQH$+VD41E)1g$On`?uYYaOd$2wH2{;6!lFVYM`iwPZq%**uFAS2vZT$CKOX-16lQiDbXi_!xsqgG_3cA z&HQ;uPAcz}=-1JJQg1h=>eOkiLu(5sF>|*zRL+UxQQ5}f2!<7ff7p!q6F3akja$1Q zvP`dZ8@hFEMq}~WlMvoDoAzF4`F8B-FT<^N9wM)t<2$pbOlBp-k4^tc z9f4F=!pFN5Y{SvZGh(W9_Pe|EA>%(4k-_?jqxUK=Sp25Kh@nNX&Wt2an77}#;`bl; zZWXDxxEQzLi+r4u2zc||?$b)#oalUQj-OuP$G@9cS?CP&N5krzkPssrWhhmRh?DQ|#9n{*fiVO7`J*V`kl#3X{Kop;g+Tg!|Cc`EXcQLZ9Zy|KQ-QRcqV}@E) zs7q1Jk-<;i+dA58X}|C4VClksunivem}!jnoA3O3XJHG{AaRKriFcUCjMTuGsiM05 z!X?$|WsLveuEqmG$NMG3y zNKG^#Kqy4;-+RNZ=Z}_j|8>8IimlE=imQ5+nT2lr4CG02q}c+@V>HT#>x)@?18+aN zibxazlt^Ag9&c4|{d`^G4ZX+nN|L)O^jsAfIINE!)7;fEYR&L;JI~y>`D|;2WMv!* zom}uP85@pfP?Wu103e}#fDT9XOx&96%h#OJW^V1S*$Y5g?D{N&hsd6lKC^lG8@N9U zXw@QG$K+Pfy*!J^g?~noL(;I{;pL`F|?=?x-f0?rVBgL21&fpcFw-K)Q6Ki+~iV(v&LFNkT_Nh@t|b zbfs76C4?d%2!tMLLQy~<1cW3&fczfr^}gTVA8WBzR#xVj^30q$bLQ;5g&@lv=Y*s@ z^18mOW-FkMlpJb=POMGwJkA4721W#kPG=Uwg3fr6&ZzjoGRX z&jA*fbUj$audjrvn&?>e!G&3Zf?1IdFFKH$o`z+5a{cMZ0X+*3*1F{-|CAy?+_-ys zTh4lS)wV{Kxi=YFOC;9|%8=7APE#R^hE=NP-1z}t@)@>kejxPi8fWgA#~Q|qO+Y|2 zE-m%kW3>X1#K$!!VL@@@gXGD^3?1qGeKc6j9!V6(;8$8=1@uwVdxD!V$`l*N8?V}U z<}n*`^V@N3MN(&mR((+Nt;`(SKc%&vz+L|F^H?PPIR<6)Xzx?yHRg>`Zkn7Lzg?j# z#V)ItV;>z4RfIsrBVZNP3pc!d{IDRx31K2g@IwmG3=IZdaX5|G0LKw;ZueJz zOY%P{g6{EZiX`Ab3J(pl6eqFZm@duvZhz7wBJDC_Wj4i{yfZs}l=(7((;>WheY~L7|G!MI^U9OwVCTHZCP!;v#Hr+4Yz?m}_;0xUN zp{s0J^|3&vk5289(3$1nXDNCa9$-mU`iInf%a2Xv5|x`qXTMut9kKH$o4&feNClz> z?juDF=#MmV6E@<%t=@F=YGn_;q1`21Q%iA4_+W1GWLizWmhbZRa?Q~KXz~P|e$D8v zEcIwUrE=2v*D3{?uFHDPYN`HE2-B>7U^!3xJQSi?d%&c6*PBfc$ z1W>1)SIDV0Y?3o(J~E3c;~$f0nj&pamk4t!TuRkzd5+1CC3`XKCTsVC$>w{nWVU0i z=ioiC`3{nv@)$%Scki4#-@<_IPt^skhtE;9eyCb)UGA9(M1$4%j_Y^IzXiFp-SRNC z3xr%1me|$uWS+2CSj0Twa?M1|LdiaKIQ%+m5a(+PY>b+ax zvmFe8bZuQf*xg)X3Fn6Ls4Ta}7vvuYB2KzINyxD6p0L(xra}R4+7!lAVdMVA(#f(C zBLB9@dh+Z3kLx4Y@xHEW`zJK{;a|kxgQ8o_9UqMsnOMy^qG?y9Gpe>XI~yRg`<}Zf zMq8WdO)3z&&hv?zbrT}*vdiEHS>2giGyTwu1v;hH&q{W^3{q37sYpP+&5?1W*j~i% ztAl5jiQ$xPZdP|iL~bsJ@=g0t=hIzPruQd>(@dYf1&2?OmCjYT(X$nLip;|f;h~3)8E7ww)&XGd?)Cy&98gChK8jXgm=yNvs zENpPwsjKT7=DYR`ydSGJ({z2COZ#xg^P2z@n@`jT+eqE=XI< z<+&hQVlg#w0ifv!V9Y+IR+V0#GoJqGDBzVHTsY!Oo7plOO|cbt@15ilOOW9AcV(vb zX_Ak)cAAz|6ixvm3O-Zo6i$vXUO>x!a8+&*rf}MFku9w=>?yLM056r{N6|^sM>SVP z`)wM`lMc86R4UT@-~?j(L|5IPDCy_9PmO-x{4%NPR4ap}Fl_iEQR;A{U4dXa<8cv!=viGsjxF4m=K6#$fJ z1!lc7MV(%dr5hx;q(yybx~$-ri}g}M!YBiv2o!Hh}t*s!}9fAq3wW8c`sAswYGTw7O-?14gl`Fl1Jm) zvLy&&8)1w$zyKGD6XHJORCVLaHLhe#xBH?^GNxmXyE0%}hqZt4G~Sy>HmKa;*C`)D z_94LAc)u!{Z_{Ct$q)h&aWmVBwWbQ0nyCw|6$coOpx!ZoWgtkjV@mkB271ExAk18e ziX#Al^yi~9RQm0=ApVONa zmh9w@k^6KmOlJRkao|~~w(TsaXG`>;ut=YiQz4_cEq-vZ;Wo1jjJN>cj;P8R>B(3E z7NV%aig4sG(8I>_nKWYBw_ztLBCJIs48lui(Q0szDt!sNFuf+@u)=o8fzi4Vzqw9~ zg|WK&^de{7?6P=lm{f}MPW(%~JwB?@1NTi8L?eF#CIzMI6*KO>-m&S%M0u_p zr-Z-%jPmCbXDbp!OHC;h6K8^^5$KP_=I=2ep}re6sX@04Gfd9C-C19yfT9 zrsjh(pgkjQ9L!`A z{A~@VEQm|7*A6!Cg+556DKli6s^)081E5ob+r*q;O@%__i>-w4UYa9S@-n*lr0AJL zg}gF62EoW~v!i?aDt^Y3Gq!RS84Yi^$e^V#r55}8l{TPC`u_EWP9ApU)evTa$o!n2 zl%}S|`ZIjU#T9?4qk^#oLmH&7DLPmx;2vF*HsW4SAlJ~wP+*3vB>?`-4SV^aYNb6& zi!u#Rz%0pmbdD-up0XO_W}((WbcDxzlcMsU-kl-n*ahQmUVfSb_d_-Mh)@kii_MAZ zQ8IGd<=g;5H5W;zs?(|uIhTl|Y{zndn>ouX7?p=+;^yD~(%B&B8L%-?5|VR%)Ip4@ z(C|b46!c{3d}<8<;qiV&@QU8c{chz@;=0qu@g)Ak`Qa-f{v(F`If*Vrvtj7ujTaMz zqaw<{9l_m02DS+%>i=EXytxd-3Lj%w49RpYTFg^BXqH>J9U|m6W3H-=SHtKn-#}OV zNAFGtJNJK4(s#>x`>+#@*>#TPfRxYmxUZQv*xk`JOBG=%=9ysnMGwI1R&~R8i(kc# zlprZ?>+N(ya~+Go4#(0Z7qgz9NnF0ne=ft+<5jKt~3m z@q41pv|ktoAf#4}qTcM4Oa$Gyv9Y(CIb-EGy4*4m z;Rz*IXn*_JW1dmk8+1W*g6R|UrKHk9!pq;aYlFKi)O9a>txlDqHl-?QLpqQa8*Ya^qnKJhG#X`RScRZ+?(ny1z<|1SzULoA${RH^V};d^ ztsBN>qgi?0MO_G5O-<@IFFc@8G+7lFAo&jOhEVVV2C#e)TJ7zsk+@i0a5ulBawEY5 zwsHje&HK3&eQo~;IDi4X{$oN1=hCC$7akCO32o@gjXpW)_UF2{FB;$TR}qX>YoP8w zXNePYQ2szzE%xNoJ zVeQzt*bVAKR8Do`J*$2Lr@hsiL0x3;Z%+I2a1=#V9omm;=vl#C;G@V6&&3ZT42M6p z<_;Yp(V^j#QaV?@b)#wWFAhif0ZcA}yLX-MlT-!=T+7N?X_2T+{yh}ch?7zRzdGJy$n3nn7@fhrLtJ_hh@ zAM!%RV<5ZBJ>-3CO>4`ix!?BqSMVl`r+Omu=lvEY@hW=v)>n$CArJLLo?Gf%1p>Z> zStbC@)jRY}!C0~@Q{nCt4Wzu7mXvjW`Rzw7E$IHrUM;IXAEO~{v3JQjl~_HVC-IRT zg*^%D1>A{{A)nQ<8{VN_2K?S^v5yn($aa)(2WQ@Pyy-T0*~0HJ5E7U!W1#_vAnC6* zbz9OB6zJCVR%woS#7ujjs&+@=H-Sk0dJo1Z`@hC#VhBV7hcAhYXtL__ z$$TH_LwRRdEY3psqy4Kpf3IbeGo;1j`n;Sirt0fp+zfn*UWu)g3;uJAjK2Ntw|ed6 zeIn*_+=r3so}lpy*Iv6a$+$DmH*a+@(!}PfnDE zct#wVQ?Pns0DKg-P`yRJuPP#*P1p|p{GfhQr!6m)d9KlyaK!~UE*I!mSMIxZ+iP5c z`jjROM9i%%l$SHfWsgjrJRC0niQK#(+S^Lr#aQ_fNTgP@SbzGQ4T3A?0_WFw(z4d7 ziJ~;&06RXK?r|c^_v_ycMW^2rMT@H^*tVFT7}i~3uB?wrfzMQP%z19-u)j6Mtv~mg z2#1|8xoIKxANAEQLUGg|Kjadm1ud0YJbh)DAdeQH*sGrkyJKJPBY+U$1c(t?>JK2@ z9u)vG^W~Mi>)n@1H)i#Bkmti|eC9U9c>I_q&xa$e6KR301N{Zcv_?3Mid)?;Q^Qvz zm3vl=D=2q{A-7aAq`N%%(j4pYD3IWLn%~p@7KlG6@WF@TF(v{(_(f`NXja-CJ{uUL zJ3$RDOY#;nsYyP27Qq^hKw7GFwyP!oUhu6_GZoQ}BQ<8byDF26vX$@LHHy^#d9h)U zX~(qGq#V*l$O9OQI~_%Ik5^)#AY>*G3hGEGVEyJb&27BS5Ndvo$+f#c;t)ux^6nD2 z?8c@l8OV3c+6V@cKo$nA3b;Lr4l7T_kgUoM&r^FM#|}N1W@}Y+z&VSle_1>FH$9v&{4F*L34xV4t9ft7YS)(pp2mBy?pw=+a;!C^IJu~YHOO54LXD{C@ zi|MXHo{$fqcJZzwSwx&`HFNHTkW|*YYS_tbAk4yc(3i|dT{wxT^Bg~}gkH_mSh7&) zYLq%VYc%1PkGAW)f!xgH(=Tv-;+|;}yG2={FME{ro2sczBTKAY>8YkuJL0rW{msKp z{{Gj>IpEUm_gAA0*2DB3zYzd@WrI(VM?a6uAB5}H{Ik%x09}#JwFM|QsQNcSe0)EyuGI zF8cDp9lM$CQUfu^-`xu|!`-9KUwIvKUB`(Z|9*`|*0Eb&Jg+9GtPZWPX? zYfi$`hi*2c3?@nXPOoVL@)xha74-N4kS&@ZavRh5#S~gQJLH>l9#iEXu!@l-Cxy9r zu|ZXr)t=(FsKoM$5HAd_zRHp5#2)eabfdl)oTT5V0AC1`kgQn<;~ykAlPt?0=AoE6 zTYcf+d*3=$&Q~p=oKRSScLLX*h*5a$zfvgbZDH=htqBWOdlQ2KD|+O*E-X_bf>!o+ z6}z(a9p&2MToG>yYPx8)ha5nA^+)#p$0HKom9M+~Qu`*eAWu$A4(HL5iMVbba4)ur z`gCrZhKB?soK6HYa`UrtuVZ=o_Z|D7%&9kkO(|&!U+yHeT=0ja^SVYTHsBFkN^G^y zR$1BU`$s7T2ApDmgWk|%n9BfSft@S&9?pVpnmGbP|F#pDmVvYF(#^maC3R)0H~6gI zA=4nJx=-bU+*co+x_ijFtvAHmj*a?4H^a?uGV7YOaK zSYB$|X?Bp>l8l?Yvk!kVG7n4tr_MK>DWuK%1kF)&4 zrQYt9h5`l`P;Se^3)5vYqga6p)+0L;|t){Q!$y>y*HQvsQ1_D~@M$yLiK-7roc!1*97 zbDaUwRwz9C=Z|jJT_V7g`F5J=dAGf5ZNT_UIA2#7;F5BMAZZQG37h2-I!o^ORuhyG zPq<{Q7g-b8h~(lD^$V%v?xtH}u~ZbYLH?M?KGm1mgKKPn$B~-UMC0=6N!ZERPTrs? zdl0K^{=q2J+YB9H6uPJMu#@WPbQvacYXFi9_^WR1J|h6$9-T!0ESYrlQ6c99U_UwX zj=?YX1w6^s;1`kl8YcBYCz%gZOEuP|qV+u7F7E~=+|(m}Eh<)&p(9PoHsbsr4AE4k zj1NeB_a7JCO(EBB6?wQr3lNIovy}hA=FI;Oo728=3Se`_>KFA=Q_e6~*uF*C2|~iP z)PqVRXv8BNlc1ttPSvPUXqFb}B(rpcNuYF798CAKFvQ7*IZx>5KK`Lph z`C;djoqTFBJSH9$YG`E?V9Qs$_EhhGv9Sn*^aLz62l&4yb=2(x zRI1(`?p=UtLn#sJy;cAqVRhOqf3?$`4-WWss>SPK2Oov>&eM3)PoQOcM`}gACeD!~ zK)iF!vwMblIVE*|(Ab!_UwB5aaaW-2(BA|nP)OzTd%2VgkL9l&6LBpQl4QbynqzVR zMC-c&;|HJlm0R6Wg)(rU0xQfDZQR zC0?|sf5B*mwugeHUh`fUu{Z`m-2ttbgb?!`CS4h12H>_-*mC&oSWe2S$LB8otgTWx zcq2n!cV5p%ftS*}iAiKD1Fy0}(?f7;mo_yo*XyZRtOBHm)bEvNK>?p?N;Og63s8Op zGF9pl9LyI!$Sz+Ic=J8Z@s-fU2flMF+H@1YBp&P}|1f*;xevSAf~p(oXi!Wq2G$NPa@6fS<@cuJWQ945ZC#mN`o+XBfc$z@n%W4fm~8T9O@ z6Wyc^K3b}Xx&^AGsHIAWkp?$F3hdKEk!wJFHG6Uk`G)8F2ZWox)yBa|iWw zs->IS=*4bm!0OO@+fRX?eDr`6pi+yfN@K5YYN#P`CX@N4tIKDLt2iWN+4!)JI0Hhy zE1fK*W=qol1DNhW^E_-Uw*mjT+2=0yt*H(qmAo9L!NRtOCV+)$kcan{FE>hH>Um#3 zI%G2JgxI_W8vl%Ux#rry$NpILXeIUA3@LBEp48BgitXa8AW3Ob6nv1{XQ=%O`MB^0 z;|jdoMc(pgjzLHo}e^S^)K$ps$q$5wb z-O`r=AGR5OP_(cns;@({*(xH|a0hey+q4;3@hCZC70w>PD0s_YaCWH9>O_@$l=<-s2JLb+ViQLSHWXdGnRJ`g141xYK6D7A`?ps2@Goh zkx1EOab@}H&K-sJFd8zg&=p2iJ~P z75cCAwp&wX?8XOBBEluCDj$HnUMqJ#)oaQ%gO9g2Qxl`t?ujHg; z{k|?y=^j_8oBf9ZM>DV!tPd9po1{f`E`c|N=zA(#OuifO$7HOvjn5!`{d`^|U3(Qa z(0Z*{_+lr+(#p2U`IoNN<&~7^iz0Bl*B3DcQhZd0zT&` zD{(&t(30E*72z9JGCK0fDW8fIr8?74a^ufLJ%MY8vu$iJOUdf6?5Wetg>`?;`12N) zzNqHSo3z0IdNAtJwzbb0_CYk;bx<5s&P_aN zBZM-N+wujlOQn@OY)-9`0Z^7T{AWwH{L#um8_kaL%at_%Sgd|d7uO0Ft)tX_^5w@n z%jLGWYwch-c)PY+e~WfH2gn@wwmIaYbN|JOBfw6VIYcHzzi|~g7~ez z(?NF%N3t&?Y-RKO#$;dLq%U%+8ovop^hLu}I&PP()j-5Ue}(eOGA_!NH2y#ZM@C7f z7|Gn7FE0#!Ql4}&o&&|LuNq|3N1oE*b0@R)BVV$?k`?nJL0b7*@)W&WG~tm?umpRA z07sRuz9Tl+S>os0OcENEMW$GnFTc^cP~;+WmltCi_*lpNv2w=6PY^=m&*Yh* zx6I!~XBHyVWa0jiFcblV$~eKaBFs;^=|Hl}0Lwf99&`c&MvnsUQ&p;8pt_q>Kd%qf1Il|3V91fiMI2WQ(u=Oa zshft>C|2s**lv**_eT?Vnpa&s0qRxF1-f1HB_9(h!1<<6aLH3+uvwrMQXZCqgfD9VaXCO_q(T&Nt( zp63%=2f)zPY30$N1lt*GXxQO+y?vCq)eKguy)1%sLU<3cmB*^uXx+3U&;lb&Ch#Y= zd?%f=*3A;OWZ}FwrSwBZgKqaytCwbn5DYr_>0)Y`yZ=U8*WLq;tqNnSqp}YETaW!L zLdz+@z{Iz(g3<1&`W06&S4sQYWST#!ZmgVJ?|#)!FuBm=yns_^QEWTHJm4~Eb5HeN zXc)RPT;|YB0$W>G@JDzK@PQWn@;xE@c`>Wo6D!xmH*kVUm8cORi$IWpIssWTjx>e2 z6cIO{q_OaFAcHm)JYE+1slj6$T6@cS)px8iRAx<37V>z*B$$dgwyRT+JULw2`kdMKW|#zoJkLkgjTUU_Q5NP= zoR!VZ)385y3KsYEajDw(tv${e{t9Itdp7QN2&WtX4-roLi*hVaMaUz+=lQy=a|;4j zX)BrrXC>8Z8A6w&Z9)o;=6e&fQYC{p$BE1uDPlo0ItE+w^&9T7g^Z)DV)aH26l6>H zT;WqnBbjuAJxph1J$#byAN-hWm+yGga$>jcnX=trVE-%)68k#sZ9}v4+?RBIhpP|t zH)eZ+wx;i%wHpWDyCCtyDB?CW)e zHKQesj6(4=HL)DSGBVm$jF$5lI;(Ebdq@M?#9s4zB^q*$)l|qE@|XTuNep zAcyX6NuWMPh)L&5Hu5XE&rqLdhR0qrUkbg0&2A>Q!bu!bQx78lcK%kr+qGj?AU*Il z`yR%x4_kp7Xw0G(5)?Tu*lX<0>Tln>( zyJr?+NgqFAC0XbNmp(RyQU~c54U@0!y-O&ZUg}PeK!p5lRC0+m&?qM}Cw2YeI{w#Q z-f5&C){>Vry2OA_bF)l_yIGA<<_F5ebob^`{(lR3XgHZ27@)c;$H|IpmNp5{IQ9leZCU>t zxQv%gUFf~uDS5Anb+g;|^slI%FinM7B-W0I#7?{#<^VaaiXV;Zd^uF}C|Li;Y?6_6 z*?wa`%?6}bW&m2!r|;ek9QLzF;uGtKqu(+=8wm!N*Y26$oYy9;n>7S(TE6@{j|4Qd zB9^c-?V#3VPWc8M&l0=m;}t>p{XR_HZP($kx3AM!vuNGjRh>8%<`JRoulSUDNq4!l z|6738`Gq@#wq}=vWCN36_75#D?>G&{1ofI%-AOXl$iKrypm!;n{*vyns;t(V!tFkX zj(Gdu%YI>MW_1ug@Z*Q~(z5nceYm`PbEp%%lU-gOZ38<>tmU~P!j->U;SXN&*8H>< zH4Ft*!DeasBTPeA|9u%`FCLiL9)zdxDLpB3u=l=Ja&5Rvwk9BzR7z@Sh6J-0#%ejw zu2$|QZ(d8wnCQ8){nk7c^JP+c2C54wS2q9q5UrMC>Ep7w*5In4OqIFot;^5c=`*Ll zv|f3YHJ||(5h|b#Vd*vAOI|6^q@DV7+%z*pm0U@->L7AAQ9Uf7?Jd zTCB}}I*AGQ&G{wSU!&TH4@~=Vua6IDbG$Gvh3_{S9((_~&~WQ*)lsiYp|73&8c)^B z-hd$E2FyZZdfDN>ZHZ*h@8LL|^elbb166U8C$#ri=ZgcTX$F`G$BcQs<>LPAUt?o$ zR)AI{eT>_E=UoqqvYsUyXs-kT7mN+z1fP5V85ipOohog8&qOHzb`*x1_+ecc*4$*} zki?(k=^bEYTZW_k6elGp#*!?YES6lB6h3u2#G<_t0BpbwWsfl5f%0WeDu3$;NsskM^<03 z!vt&=7iNymZ%XaGF>K9SOCA=IS4hlyTMq0lO2NRMiNZUSqt+yo^&e~Xne>_UnfF=r zAp_@Q3U+U*1hiDx!iU?B|NI!Z_;-^c!|5)eU#K1(xP-f6Y(A#nhNIAAriwwZS;c*R zH~N)An^xWIeG^*Ny=8m%PQy$wMLxyrimHmniuQ^=l`Fqr_Qv$a^(OSv|LycG);I`@ z;TtKz%yOETuEfirS@Y6&lRTH-W3JXky3R?q&A*)-B%!8l;t zF}|2!41|{!xmzNoIIM_L+*Um0`mgKEPgqZfwrUZowaC-MOqH}O?{3|c>dJ-II|eH) zsTmWK*IN$dS{=V%HPFjhbvTDFr;ZEi&2gyDSTm@YR8tL1n~_qPm7Z0bHJNo-GyJiO zRm12G)mNQt%%TIe|2I$^e|wQh5eK<^w45aE)n}_zUR?Ygz*V?h>o%_lhaQ=5tPE6z z*|~GzxgW0;J)RDI>t@@^3Hd5p>#&o)VDmt3HBM#fNq54qv+`IzW(4oiS_hgn_O5EM zor3@t=k#Q0)&!TFl8};=0!?|FlAgl--_UU|km&Mz?2?j_ynh8CW8a z{;_e`p)_ZAA6{!maD!Boe`MR-S1Mii>;YX?vr*;)uj*ALk?OlMlz*8t}6hi${)s=MpVgr_;CohWA8`#DkWy2`?s&KK)v zPhOtql$)Tr(DK6vi$;eLFfPDsc17AlvLNlm;YX=kFVQ?XKDwmI930^&c)_?4dGZ{h zlEP;KE$c(>tsm~Ug@IugVA)nvl{mO6%ot`5^MU=fd}JPpSC9XicCr@~tfzk)Or}N7 z0Qv88K3Uvf3r9v~7TLxB_xs4J>Pvs!IWl$D+@1dxiU5P@!C#w3#!UVH_xOv5EfSl3 VhL3#7$M&;o^tFw(Dm5IV{|}tHa(Vy& literal 0 HcmV?d00001 diff --git a/doc/guides/prog_guide/graph_lib.rst b/doc/guides/prog_guide/graph_lib.rst index ad09bdfe26..0db7b6d99c 100644 --- a/doc/guides/prog_guide/graph_lib.rst +++ b/doc/guides/prog_guide/graph_lib.rst @@ -547,3 +547,291 @@ on success packet is enqueued to ``udp4_input`` node. Hash lookup is performed in ``udp4_input`` node with registered destination port and destination port in UDP packet , on success packet is handed to ``udp_user_node``. + +Feature Arc +----------- +`Feature arc` represents an ordered list of `protocols/features` at a given +networking layer. It is a high level abstraction to connect various `feature` +nodes in `rte_graph` instance and allows seamless packets steering based on the +sequence of enabled features at runtime on each interface. + +`Features` (or feature nodes) are nodes which handle partial or complete +protocol processing in a given direction. For instance, `ipv4-rewrite` and +`IPv4 IPsec encryption` are outbound features while `ipv4-lookup` and `IPv4 +IPsec decryption` are inbound features. Further, `ipv4-rewrite` and `IPv4 +IPsec encryption` can collectively represent a `feature arc` towards egress +direction with ordering constraints that `IPv4 IPsec encryption` must be +performed before `ipv4-rewrite`. Similarly, `IPv4 IPsec decryption` and +`ipv4-lookup` can represent a `feature arc` in an ingress direction. Both of +these `feature arc` can co-exist at an IPv4 layer in egress and ingress +direction respectively. + +A `feature` can be represented by a single node or collection of multiple nodes +performing feature processing collectively. + +.. figure:: img/feature_arc-1.png + :alt: feature-arc-1 + :width: 350px + :align: center + + Feature Arc overview + +Each `feature arc` is associated with a `Start` node from which all features in +a feature arc are connected. A `start` node itself is not a `feature` node but +it is where `first enabled feature` is checked in fast path. In above figure, +`Node-A` represents a `start node`. There may be a `Sink` node as well which +is child node for every feature in an arc. 'Sink` node is responsible of +consuming those packets which are not consumed by intermediate enabled features +between `start` and `sink` node. `Sink` node, if present, is the last enabled +feature in a feature arc. A `feature` node statically connected to `start` node +must also be added via feature arc API, `rte_graph_feature_add()``. Here `Node-B` +acts as a `sink` node which is statically linked to `Node A`. `Feature` nodes +are connected via `rte_graph_feature_add()` which takes care of connecting +all `feature` nodes with each other and start node. + +.. code-block:: bash + :linenos: + :emphasize-lines: 8 + :caption: Node-B statically linked to Node-A + + static struct rte_node_register node_A_node = { + .process = node_A_process_func, + ... + ... + .name = "Node-A", + .next_nodes = + { + [0] = "Node-B", + }, + .nb_edges = 1, + }; + +When multiple features are enabled on an interface, it may be required to steer +packets across `features` in a given order. For instance, if `Feature 1` and +`Feature 2` both are enabled on an interface ``X``, it may be required to send +packets to `Feature-1` before `Feature-2`. Such ordering constraints can be +easily expressed with `feature arc`. In this case, `Feature 1` is called as +``First Feature`` and `Feature 2` is called as ``Next Feature`` to `Feature 1`. + +.. figure:: img/feature_arc-2.png + :alt: feature-arc-2 + :width: 600px + :align: center + + First and Next features and their ordering + +In similar manner, even application specific ``custom features`` can be hooked +to standard nodes. It is to be noted that this `custom feature` hooking to +`feature arc` aware node does not require any code changes. + +It may be obvious by now that `features` enabled on one interface does not +affect packets on other interfaces. In above example, if no feature is +enabled on an interface ``X``, packets destined to interface ``X`` would be +directly sent to `Node-B` from `Node-A`. + +.. figure:: img/feature_arc-3.png + :alt: feature-arc-3 + :width: 550px + :align: center + + Feature-2 consumed/non-consumed packet path + +When a `Feature-X` node receives packets via feature arc, it may decide whether +to ``consume packet`` or send to `next enabled feature`. A node can consume +packet by freeing it, sending it on wire or enqueuing it to hardware queue. If a +packet is not consumed by a `Feature-X` node, it may send to `next enabled +feature` on an interface. In above figure, `Feature-2` nodes are represented to +consume packets. Classic example for a node performing consume and non-consume +operation on packets would be IPsec policy node where all packets with +``protect`` actions are consumed while remaining packets with ``bypass`` +actions are sent to next enabled feature. + +In fast path feature node may require to lookup local data structures for each +interface. For example, retrieving policy database per interface for IPsec +processing. ``rte_graph_feature_enable`` API allows to set application +specific cookie per feature per interface. `Feature data` object maintains this +cookie in fast path for each interface. + +`Feature arc design` allows to enable subsequent features in a control plane +without stopping workers which are accessing feature arc's fast path APIs in +``rte_graph_walk()`` context. However for disabling features require RCU like +scheme for synchronization. + +Programming model +~~~~~~~~~~~~~~~~~ +Feature Arc Objects +^^^^^^^^^^^^^^^^^^^ +Control plane and fast path APIs deals with following objects: + +Feature arc +*********** +``rte_graph_feature_arc_t`` is a handle to feature arc which is created via +``rte_graph_feature_arc_create()``. It is a `uint64_t` size object which can be +saved in feature node's context. This object can be translated to fast path +feature arc object ``struct rte_graph_feature_arc`` which is an input +argument to all fast path APIs. Control plane APIs majorly takes +`rte_graph_feature_arc_t` object as an input. + +Feature List +************ +Each feature arc holds two feature lists: `active` and `passive`. While worker +cores uses `active` list, control plane APIs uses `passive` list for +enabling/disabling a feature on any interface with in a arc. After successful +feature enable/disable, ``rte_graph_feature_enable()``/ +``rte_graph_feature_disable()`` atomically switches passive list to active list +and vice-versa. Most of the fast path APIs takes active list as an argument +(``rte_graph_feature_rt_list_t``), which feature node can obtain in start of +it's `process_func()` via ``rte_graph_feature_arc_has_any_feature()`` (in `start` +node) or ``rte_graph_feature_arc_has_feature()`` (in next feature nodes). + +Each feature list holds RTE_GRAPH_MAX_FEATURES number of features and +associated feature data for every interface index + +Feature +******** +Feature is a data structure which holds `feature data` object for every +interface. It is represented via ``rte_graph_feature_t`` which is a `uint8_t` +size object. Fast path internal structure ``struct rte_graph_feature`` can be +obtained from ``rte_graph_feature_t`` via ``rte_graph_feature_get()`` API. + +In `start` node `rte_graph_feature_arc_first_feature_get()` can be used to get +first enabled `rte_graph_feature_t` object for an interface. `rte_edge` from +`start` node to first enabled feature is provided by +``rte_graph_feature_arc_feature_set()`` API. + +In `feature nodes`, next enabled feature is obtained by providing current feature +as an input to ``rte_graph_feature_arc_next_feature_get()`` API. + +Feature data +************ +Feature data object is maintained per feature per interface which holds +following information in fast path + +- ``rte_edge_t`` to send packet to next enabled feature +- ``Next enabled feature`` on current interface +- ``User_data`` per feature per interface set by application via `rte_graph_feature_enable()` + +Enabling Feature Arc processing +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +By default, feature arc processing is disabled in `rte_graph_create()`. To +enable feature arc processing in fast path, `rte_graph_create()` API should be +invoked with `feature_arc_enable` flag set as `true` + +.. code-block:: bash + :linenos: + :emphasize-lines: 3 + :caption: Enabling feature are processing in rte_graph_create() + + struct rte_graph_param graph_conf; + + graph_conf.feature_arc_enable = true; + struct rte_graph *graph = rte_graph_create("graph_name", &graph_conf); + +Further as an optimization technique, `rte_graph_walk()` would call newly added +``feat_arc_proc()`` node callback function (if non-NULL) instead of +``process`` + +.. code-block:: bash + :linenos: + :emphasize-lines: 3 + :caption: Feature arc specific node callback function + + static struct rte_node_register ip4_rewrite_node = { + .process = ip4_rewrite_node_process, + .feat_arc_proc = ip4_rewrite_feature_node_process, + .name = "ip4_rewrite", + ... + ... + }; + +If `feat_arc_proc` is not provided in node registration, `process_func` would +be called by `rte_graph_walk()` + +Sample Usage +^^^^^^^^^^^^ +.. code-block:: bash + :linenos: + :caption: Feature arc sample usage + + #define MAX_FEATURES 10 + #define MAX_INDEXES 5 + + static uint16_t + feature2_feature_node_process (struct rte_graph *graph, struct + rte_node *node, void **objs, uint16_t nb_objs) + { + /* features may be enabled */ + } + static uint16_t + feature2_node_process (struct rte_graph *graph, struct + rte_node *node, void **objs, uint16_t nb_objs) + { + /* Feature arc is disabled in rte_graph_create() */ + } + + static uint16_t + feature2_node_process (struct rte_graph *graph, struct + rte_node *node, void **objs, uint16_t nb_objs) + { + /* Feature arc may be enabled or disabled as this process_func() would + * be called for the case when feature arc is enabled in rte_graph_create() + * and also the case when it is disabled + */ + } + + static struct rte_node_register feature2_node = { + .process = feature2_node_process, + .feat_arc_proc = feature2_feature_node_process, + .name = "feature2", + .init = feature2_init_func, + ... + ... + }; + + static struct rte_node_register feature1_node = { + .process = feature1_node_process, + .feat_arc_proc = NULL, + .name = "feature1", + ... + ... + }; + + int worker_cb(void *_em) + { + rte_graph_feature_arc_t arc; + uint32_t user_data; + + rte_graph_feature_arc_lookup_by_name("sample_arc", &arc); + + /* From control thread context (like CLII): + * Enable feature 2 on interface index 4 + */ + if (rte_lcore_id() == rte_get_main_lcore) { + user_data = 0x1234; + rte_graph_feature_enable(arc, 4 /* interface index */, "feature2", user_data); + } else { + while(1) + rte_graph_walk); + } + } + + int main(void) + { + struct rte_graph_param graph_conf; + rte_graph_feature_arc_t arc; + + if (rte_graph_feature_arc_create("sample_arc", MAX_FEATURES, MAX_INDEXES, &arc)) + return -1; + + rte_graph_feature_add(arc, "feature1", NULL, NULL); + rte_graph_feature_add(arc, "feature2", "feature1" /* add feature2 after feature 1*/, NULL); + + /* create graph*/ + ... + ... + graph_conf.feature_arc_enable = true; + + struct rte_graph *graph = rte_graph_create("sample_graph", &graph_conf); + + rte_eal_mp_remote_launch(worker_cb, arg, CALL_MAIN); + } diff --git a/doc/guides/prog_guide/img/feature_arc-1.png b/doc/guides/prog_guide/img/feature_arc-1.png new file mode 100644 index 0000000000000000000000000000000000000000..d518000f42753ea7a1a71668c2735c48fc75c3ed GIT binary patch literal 61532 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 z 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

UwR}KPH>O(NU%Ch*gAtgQ{ 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

SJ5f0;KrL6mm(Cs&n>h&_#H1O&3DeBPnnkQ zWoT}DY7r}4e(ddPpn+`@fX<~Zu{$T*C@ejXB+E(o!pp;oTlZE>jk;o%u`C^ zT@SBZYI(X?@&p+^bV6M0LEL6(e8Ax17fF2Yz_{(;!y|%<%niIU799j;0noya)pu(V z_p^U|VhEA|l7T{(eD>xPIx1s`ogI64lk%~ITN!#oAwFQ%ZTrN1OC~7&>H=_9tBQDy z6xXl)xXH;jNnOF(9wfTouyyBz9PRGM-nOe4I_+m2r5QuL{Euh7ojFpLz^(vbmHzof zNauD0@kZrCs4mFmZp=J?&3_Ds3ozaCkxn5!=UOInEjng(OXF`J>mWrQe%t?;^QGBTR}6OBH@S@=Blxr<~y8^8K5$#wSkaP4Va9;Qsfhm?;{%senzBf5zGPm|ZYj>;0G> zlTCvzd04%JLzF7K-d8VmT%4o-PZ6z7wFTZ1-fNUseB^)gaSWL9emcS)zg6x?=TZp+ zgp1Mb7B#jPHQigyiBD!#5Vo3rMKV=ON{;WJUXjAy79WRqn5QweTy^zf+MTf?g&+k+ z+*RgOxE#jj- zzvxrf=jSFFYOx$;PUn$n8v3CtA1(vKq-XjJ7qh*keF)S6^`NDEt2(!Wld2)9M39iG z!~V0ZrA@8bGS>`nL{(3{m|!F>!kZN~Mi8TgaM&p)o38Z)rY{a?84iN<@r}t8yW-LipWQ9jRiI8R z{il|RHmi8z%A1m6Sef9%-k+@V-Xt+{LyVr*lbDIE?x5u5vvk|OmJn{jVrTZm-Q-2< z=75bIXCY>jx^rNNj&UM7rJtH>Et-@uSfBt@#hJERC0BAFd#_=`aOQ8 z9!^fanP9-Gj}0JQAaM!y>KDV~F2-GsGmbNjL&c%vtmAf*A!kdLZ)%vf8U4o!GW$He zdmr;eG+*zY@2vID4nen-)DIR0&n@PyI&!od_AJZ0Yg(W3nt<_Zp;o&<+>!kT_d|VW z_Z!cNCbn0Gn^EJfb4t^Nqap5IxGI6E^Fr71UlEs$0? zL*!?CG?&#uMU8Az`BCGHvMuXVDfCIdrQo3KM!T9bL%8|w-;+KQ%M(76%g#FALm10; zhfJ?CBqe+*S}H~>b_wI%rT@KUIGfbCPO_`EsY#3&0OB2LZ^c>N`Fbp{e*?A9OX5_&pPCM4tfPb&yR~3Y9!N8M+ik zi}Nt8ksV6uPwdC_KkHA~PS{TLAFc?m$Y!paFM(;c-7|~?J_P2EodtmO%-?C2RHmf} p{>NgE-}{4Q-@X4wp{=~Z-F;h55Us2a?>;c=!Szipm0qxq_%EcAi=hAj literal 0 HcmV?d00001 diff --git a/doc/guides/prog_guide/img/feature_arc-2.png b/doc/guides/prog_guide/img/feature_arc-2.png diff --git a/doc/guides/prog_guide/img/feature_arc-3.png b/doc/guides/prog_guide/img/feature_arc-3.png new file mode 100644 index 0000000000000000000000000000000000000000..3991e0aed2933bfa01e9ffad654f4c40a639bc53 GIT binary patch literal 143697 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 JynBzl{|6wHR9pZ6 literal 0 HcmV?d00001 -- 2.43.0