doc/guides/sample_app_ug/rxtx_callbacks.rst

   1 ..  SPDX-License-Identifier: BSD-3-Clause
   2     Copyright(c) 2015 Intel Corporation.
   3
   4 RX/TX Callbacks Sample Application
   5 ==================================
   6
   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.
  11
  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.
  15
  16
  17 Compiling the Application
  18 -------------------------
  19
  20 To compile the sample application see :doc:`compiling`.
  21
  22 The application is located in the ``rxtx_callbacks`` sub-directory.
  23
  24 The callbacks feature requires that the ``CONFIG_RTE_ETHDEV_RXTX_CALLBACKS``
  25 setting is on in the ``config/common_`` config file that applies to the
  26 target. This is generally on by default:
  27
  28 .. code-block:: console
  29
  30     CONFIG_RTE_ETHDEV_RXTX_CALLBACKS=y
  31
  32 Running the Application
  33 -----------------------
  34
  35 To run the example in a ``linuxapp`` environment:
  36
  37 .. code-block:: console
  38
  39     ./build/rxtx_callbacks -l 1 -n 4
  40
  41 Refer to *DPDK Getting Started Guide* for general information on running
  42 applications and the Environment Abstraction Layer (EAL) options.
  43
  44
  45
  46 Explanation
  47 -----------
  48
  49 The ``rxtx_callbacks`` application is mainly a simple forwarding application
  50 based on the :doc:`skeleton`. See that section of the documentation for more
  51 details of the forwarding part of the application.
  52
  53 The sections below explain the additional RX/TX callback code.
  54
  55
  56 The Main Function
  57 ~~~~~~~~~~~~~~~~~
  58
  59 The ``main()`` function performs the application initialization and calls the
  60 execution threads for each lcore. This function is effectively identical to
  61 the ``main()`` function explained in :doc:`skeleton`.
  62
  63 The ``lcore_main()`` function is also identical.
  64
  65 The main difference is in the user defined ``port_init()`` function where the
  66 callbacks are added. This is explained in the next section:
  67
  68
  69 The Port Initialization  Function
  70 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  71
  72 The main functional part of the port initialization is shown below with
  73 comments:
  74
  75 .. code-block:: c
  76
  77     static inline int
  78     port_init(uint16_t port, struct rte_mempool *mbuf_pool)
  79     {
  80         struct rte_eth_conf port_conf = port_conf_default;
  81         const uint16_t rx_rings = 1, tx_rings = 1;
  82         struct ether_addr addr;
  83         int retval;
  84         uint16_t q;
  85
  86         /* Configure the Ethernet device. */
  87         retval = rte_eth_dev_configure(port, rx_rings, tx_rings, &port_conf);
  88         if (retval != 0)
  89             return retval;
  90
  91         /* Allocate and set up 1 RX queue per Ethernet port. */
  92         for (q = 0; q < rx_rings; q++) {
  93             retval = rte_eth_rx_queue_setup(port, q, RX_RING_SIZE,
  94                     rte_eth_dev_socket_id(port), NULL, mbuf_pool);
  95             if (retval < 0)
  96                 return retval;
  97         }
  98
  99         /* Allocate and set up 1 TX queue per Ethernet port. */
 100         for (q = 0; q < tx_rings; q++) {
 101             retval = rte_eth_tx_queue_setup(port, q, TX_RING_SIZE,
 102                     rte_eth_dev_socket_id(port), NULL);
 103             if (retval < 0)
 104                 return retval;
 105         }
 106
 107         /* Start the Ethernet port. */
 108         retval = rte_eth_dev_start(port);
 109         if (retval < 0)
 110             return retval;
 111
 112         /* Enable RX in promiscuous mode for the Ethernet device. */
 113         rte_eth_promiscuous_enable(port);
 114
 115
 116         /* Add the callbacks for RX and TX.*/
 117         rte_eth_add_rx_callback(port, 0, add_timestamps, NULL);
 118         rte_eth_add_tx_callback(port, 0, calc_latency, NULL);
 119
 120         return 0;
 121     }
 122
 123
 124 The RX and TX callbacks are added to the ports/queues as function pointers:
 125
 126 .. code-block:: c
 127
 128         rte_eth_add_rx_callback(port, 0, add_timestamps, NULL);
 129         rte_eth_add_tx_callback(port, 0, calc_latency,   NULL);
 130
 131 More than one callback can be added and additional information can be passed
 132 to callback function pointers as a ``void*``. In the examples above ``NULL``
 133 is used.
 134
 135 The ``add_timestamps()`` and ``calc_latency()`` functions are explained below.
 136
 137
 138 The add_timestamps() Callback
 139 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 140
 141 The ``add_timestamps()`` callback is added to the RX port and is applied to
 142 all packets received:
 143
 144 .. code-block:: c
 145
 146     static uint16_t
 147     add_timestamps(uint16_t port __rte_unused, uint16_t qidx __rte_unused,
 148             struct rte_mbuf **pkts, uint16_t nb_pkts, void *_ __rte_unused)
 149     {
 150         unsigned i;
 151         uint64_t now = rte_rdtsc();
 152
 153         for (i = 0; i < nb_pkts; i++)
 154             pkts[i]->udata64 = now;
 155
 156         return nb_pkts;
 157     }
 158
 159 The DPDK function ``rte_rdtsc()`` is used to add a cycle count timestamp to
 160 each packet (see the *cycles* section of the *DPDK API Documentation* for
 161 details).
 162
 163
 164 The calc_latency() Callback
 165 ~~~~~~~~~~~~~~~~~~~~~~~~~~~
 166
 167 The ``calc_latency()`` callback is added to the TX port and is applied to all
 168 packets prior to transmission:
 169
 170 .. code-block:: c
 171
 172     static uint16_t
 173     calc_latency(uint16_t port __rte_unused, uint16_t qidx __rte_unused,
 174             struct rte_mbuf **pkts, uint16_t nb_pkts, void *_ __rte_unused)
 175     {
 176         uint64_t cycles = 0;
 177         uint64_t now = rte_rdtsc();
 178         unsigned i;
 179
 180         for (i = 0; i < nb_pkts; i++)
 181             cycles += now - pkts[i]->udata64;
 182
 183         latency_numbers.total_cycles += cycles;
 184         latency_numbers.total_pkts   += nb_pkts;
 185
 186         if (latency_numbers.total_pkts > (100 * 1000 * 1000ULL)) {
 187             printf("Latency = %"PRIu64" cycles\n",
 188                     latency_numbers.total_cycles / latency_numbers.total_pkts);
 189
 190             latency_numbers.total_cycles = latency_numbers.total_pkts = 0;
 191         }
 192
 193         return nb_pkts;
 194     }
 195
 196 The ``calc_latency()`` function accumulates the total number of packets and
 197 the total number of cycles used. Once more than 100 million packets have been
 198 transmitted the average cycle count per packet is printed out and the counters
 199 are reset.