Lines Matching refs:node
7 Graph architecture abstracts the data processing functions as a ``node`` and
12 create, lookup, dump and destroy on graph and node operations such as clone,
14 cluster to monitor per graph and per node stats.
25 - Low overhead graph walk and node enqueue.
35 similar packet processing code to a node will reduce the I cache and D
39 - Allow SIMD instructions for packet processing of the node.-
42 optimizations as a node.
51 - Disable node statistics (using ``RTE_LIBRTE_GRAPH_STATS`` config option)
64 Anatomy of a node
66 The node is the basic building block of the graph framework.
68 A node consists of:
74 ``rte_graph_walk()`` function when there is data to be processed by the node.
75 A graph node process the function using ``process()`` and enqueue to next
76 downstream node using ``rte_node_enqueue*()`` function.
81 It is memory allocated by the library to store the node-specific context
88 a node gets attached to a graph.
94 node gets detached to a graph.
99 It is the name of the node. When a node registers to graph library, the library
101 node. ``rte_node_from_name()``, ``rte_node_id_to_name()`` are the node
107 The number of downstream nodes connected to this node. The ``next_nodes[]``
110 objects. Consumers of the node APIs are free to update the ``next_node[]``
116 The dynamic array to store the downstream nodes connected to this node. Downstream
117 node should not be current node itself or a source node.
119 Source node:
129 * Node implementer creates the node by implementing ops and attributes of
132 * The library registers the node by invoking RTE_NODE_REGISTER on library load
143 Once nodes are available to the program, Application or node public API
150 Provide the ``next_nodes[]`` at the node registration time. See ``struct rte_node_register::nb_edg…
151 This is a use case to address the static node scheme where one knows upfront the
152 ``next_nodes[]`` of the node.
157 to update the ``next_nodes[]`` links for the node runtime but before graph create.
161 Use ``rte_node_clone()`` to clone a already existing node, created using RTE_NODE_REGISTER.
163 of the node and creates a new one. The name for cloned node shall be
175 the required nodes. The application can provide a set of node patterns to
189 node of port 0 and queue 0, all ipv4* nodes in the system,
190 and ethdev tx node of all ports.
216 The fast-path object for the node is ``struct rte_node``.
219 the user needs to update the context of the node hence access to
227 Get the node statistics using graph cluster
229 The user may need to know the aggregate stats of the node across
236 to get the aggregate node statistics.
256 The ``process()`` function of a node is the fast-path function and that needs
265 ``process()`` function can move the obj burst to the next node either using
271 The second kind of such node is ``intermediate nodes`` that decide what is the
276 * Secondly, each packet needs to be queued to its next node.
282 each node using the same next node for all its packets, the cost of moving every
283 pointer from current node's stream to next node's stream could be avoided.
285 just move stream from the current node to the next node with least number of cycles.
287 to the same next node, node implementation should be also having worst-case
288 handling where every packet could be going to different next node.
290 Example of intermediate node implementation with home run:
292 1. Start with speculation that next_node = node->ctx.
293 This could be the next_node application used in the previous function call of this node.
299 and process current pkt_set to find their next node
301 4. if all the next nodes of the current pkt_set match speculated next node,
303 continue the loop without actually moving them to the next node. else if there is
312 to single next node. So, the current stream can be moved to next node using
313 ``rte_node_next_stream_move(node, next_node)``.
314 This is the ``home run`` where memcpy of buffer pointers to next node is avoided.
316 7. Update the ``node->ctx`` with more probable next node.
345 This node does ``rte_eth_rx_burst()`` into stream buffer passed to it
346 (src node stream) and does ``rte_node_next_stream_move()`` only when
348 queue that it gets from node->ctx. For each (port X, rx_queue Y),
350 ``rte_node_eth_config()`` along with updating ``node->ctx``.
355 This node does ``rte_eth_tx_burst()`` for a burst of objs received by it.
357 node->ctx. For each (port X), this ``rte_node`` is cloned from
359 along with updating node->context.
367 This node frees all the objects passed to it considering them as
372 This node is an intermediate node that does LPM lookup for the received
373 ipv4 packets and the result determines each packets next node.
378 On LPM lookup failure, objects are redirected to pkt_drop node.
380 To achieve home run, node use ``rte_node_stream_move()`` as mentioned in above
385 This node gets packets from ``ip4_lookup`` node with next-hop id for each
388 the packet out to a particular ethdev_tx node.
393 This node ignores the set of objects passed to it and reports that all are