1 .. SPDX-License-Identifier: BSD-3-Clause
2 Copyright(c) 2015 Intel Corporation.
4 RX/TX Callbacks Sample Application
5 ==================================
7 The RX/TX Callbacks sample application is a packet forwarding application that
8 demonstrates the use of user defined callbacks on received and transmitted
9 packets. The application performs a simple latency check, using callbacks, to
10 determine the time packets spend within the application.
12 In the sample application a user defined callback is applied to all received
13 packets to add a timestamp. A separate callback is applied to all packets
14 prior to transmission to calculate the elapsed time, in CPU cycles.
16 If hardware timestamping is supported by the NIC, the sample application will
17 also display the average latency since the packet was timestamped in hardware,
18 on top of the latency since the packet was received and processed by the RX
21 Compiling the Application
22 -------------------------
24 To compile the sample application see :doc:`compiling`.
26 The application is located in the ``rxtx_callbacks`` sub-directory.
28 The callbacks feature requires that the ``CONFIG_RTE_ETHDEV_RXTX_CALLBACKS``
29 setting is on in the ``config/common_`` config file that applies to the
30 target. This is generally on by default:
32 .. code-block:: console
34 CONFIG_RTE_ETHDEV_RXTX_CALLBACKS=y
36 Running the Application
37 -----------------------
39 To run the example in a ``linux`` environment:
41 .. code-block:: console
43 ./build/rxtx_callbacks -l 1 -n 4 -- [-t]
45 Use -t to enable hardware timestamping. If not supported by the NIC, an error
48 Refer to *DPDK Getting Started Guide* for general information on running
49 applications and the Environment Abstraction Layer (EAL) options.
56 The ``rxtx_callbacks`` application is mainly a simple forwarding application
57 based on the :doc:`skeleton`. See that section of the documentation for more
58 details of the forwarding part of the application.
60 The sections below explain the additional RX/TX callback code.
66 The ``main()`` function performs the application initialization and calls the
67 execution threads for each lcore. This function is effectively identical to
68 the ``main()`` function explained in :doc:`skeleton`.
70 The ``lcore_main()`` function is also identical.
72 The main difference is in the user defined ``port_init()`` function where the
73 callbacks are added. This is explained in the next section:
76 The Port Initialization Function
77 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
79 The main functional part of the port initialization is shown below with
85 port_init(uint16_t port, struct rte_mempool *mbuf_pool)
87 struct rte_eth_conf port_conf = port_conf_default;
88 const uint16_t rx_rings = 1, tx_rings = 1;
89 struct rte_ether_addr addr;
93 /* Configure the Ethernet device. */
94 retval = rte_eth_dev_configure(port, rx_rings, tx_rings, &port_conf);
98 /* Allocate and set up 1 RX queue per Ethernet port. */
99 for (q = 0; q < rx_rings; q++) {
100 retval = rte_eth_rx_queue_setup(port, q, RX_RING_SIZE,
101 rte_eth_dev_socket_id(port), NULL, mbuf_pool);
106 /* Allocate and set up 1 TX queue per Ethernet port. */
107 for (q = 0; q < tx_rings; q++) {
108 retval = rte_eth_tx_queue_setup(port, q, TX_RING_SIZE,
109 rte_eth_dev_socket_id(port), NULL);
114 /* Start the Ethernet port. */
115 retval = rte_eth_dev_start(port);
119 /* Enable RX in promiscuous mode for the Ethernet device. */
120 retval = rte_eth_promiscuous_enable(port);
124 /* Add the callbacks for RX and TX.*/
125 rte_eth_add_rx_callback(port, 0, add_timestamps, NULL);
126 rte_eth_add_tx_callback(port, 0, calc_latency, NULL);
132 The RX and TX callbacks are added to the ports/queues as function pointers:
136 rte_eth_add_rx_callback(port, 0, add_timestamps, NULL);
137 rte_eth_add_tx_callback(port, 0, calc_latency, NULL);
139 More than one callback can be added and additional information can be passed
140 to callback function pointers as a ``void*``. In the examples above ``NULL``
143 The ``add_timestamps()`` and ``calc_latency()`` functions are explained below.
146 The add_timestamps() Callback
147 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
149 The ``add_timestamps()`` callback is added to the RX port and is applied to
150 all packets received:
155 add_timestamps(uint16_t port __rte_unused, uint16_t qidx __rte_unused,
156 struct rte_mbuf **pkts, uint16_t nb_pkts, void *_ __rte_unused)
159 uint64_t now = rte_rdtsc();
161 for (i = 0; i < nb_pkts; i++)
162 pkts[i]->udata64 = now;
167 The DPDK function ``rte_rdtsc()`` is used to add a cycle count timestamp to
168 each packet (see the *cycles* section of the *DPDK API Documentation* for
172 The calc_latency() Callback
173 ~~~~~~~~~~~~~~~~~~~~~~~~~~~
175 The ``calc_latency()`` callback is added to the TX port and is applied to all
176 packets prior to transmission:
181 calc_latency(uint16_t port __rte_unused, uint16_t qidx __rte_unused,
182 struct rte_mbuf **pkts, uint16_t nb_pkts, void *_ __rte_unused)
185 uint64_t now = rte_rdtsc();
188 for (i = 0; i < nb_pkts; i++)
189 cycles += now - pkts[i]->udata64;
191 latency_numbers.total_cycles += cycles;
192 latency_numbers.total_pkts += nb_pkts;
194 if (latency_numbers.total_pkts > (100 * 1000 * 1000ULL)) {
195 printf("Latency = %"PRIu64" cycles\n",
196 latency_numbers.total_cycles / latency_numbers.total_pkts);
198 latency_numbers.total_cycles = latency_numbers.total_pkts = 0;
204 The ``calc_latency()`` function accumulates the total number of packets and
205 the total number of cycles used. Once more than 100 million packets have been
206 transmitted the average cycle count per packet is printed out and the counters