uint32_t service_id;
if (rte_event_eth_rx_adapter_service_id_get(0, &service_id) == 0)
rte_service_map_lcore_set(service_id, RX_CORE_ID);
15.2.1.6. Starting the Adapter Instance
The application calls rte_event_eth_rx_adapter_start() to start the adapter.
This function calls the start callbacks of the eventdev PMDs for hardware based
eventdev-ethdev connections and rte_service_run_state_set() to enable the
service function if one exists.
The eventdev to which the event_eth_rx_adapter is connected needs to
be started before calling rte_event_eth_rx_adapter_start().
15.2.1.7. Getting Adapter Statistics
The rte_event_eth_rx_adapter_stats_get() function reports counters defined
in struct rte_event_eth_rx_adapter_stats. The received packet and
enqueued event counts are a sum of the counts from the eventdev PMD callbacks
if the callback is supported, and the counts maintained by the service function,
if one exists. The service function also maintains a count of cycles for which
it was not able to enqueue to the event device.
15.2.1.8. Getting Adapter queue config
The rte_event_eth_rx_adapter_queue_conf_get() function reports
flags for handling received packets, event queue identifier, scheduler type,
event priority, polling frequency of the receive queue and flow identifier
in struct rte_event_eth_rx_adapter_queue_conf.
15.2.1.9. Set/Get adapter runtime configuration parameters
The runtime configuration parameters of adapter can be set/get using
rte_event_eth_rx_adapter_runtime_params_set() and
rte_event_eth_rx_adapter_runtime_params_get() respectively.
The parameters that can be set/get are defined in
struct rte_event_eth_rx_adapter_runtime_params.
15.2.1.10. Getting and resetting Adapter queue stats
The rte_event_eth_rx_adapter_queue_stats_get() function reports
adapter queue counters defined in struct rte_event_eth_rx_adapter_queue_stats.
This function reports queue level stats only when queue level event buffer is
used otherwise it returns -EINVAL.
The rte_event_eth_rx_adapter_queue_stats_reset() function can be used to
reset queue level stats when queue level event buffer is in use.
15.2.1.11. Getting Adapter Instance ID
The rte_event_eth_rx_adapter_instance_get() function reports
Rx adapter instance ID for a specified ethernet device ID and Rx queue index.
15.2.1.12. Interrupt Based Rx Queues
The service core function is typically set up to poll ethernet Rx queues for
packets. Certain queues may have low packet rates and it would be more
efficient to enable the Rx queue interrupt and read packets after receiving
the interrupt.
The servicing_weight member of struct rte_event_eth_rx_adapter_queue_conf
is applicable when the adapter uses a service core function. The application
has to enable Rx queue interrupts when configuring the ethernet device
using the rte_eth_dev_configure() function and then use a servicing_weight
of zero when adding the Rx queue to the adapter.
The adapter creates a thread blocked on the interrupt, on an interrupt this
thread enqueues the port id and the queue id to a ring buffer. The adapter
service function dequeues the port id and queue id from the ring buffer,
invokes the rte_eth_rx_burst() to receive packets on the queue and
converts the received packets to events in the same manner as packets
received on a polled Rx queue. The interrupt thread is affinitized to the same
CPUs as the lcores of the Rx adapter service function, if the Rx adapter
service function has not been mapped to any lcores, the interrupt thread
is mapped to the main lcore.
15.2.1.13. Rx Callback for SW Rx Adapter
For SW based packet transfers, i.e., when the
RTE_EVENT_ETH_RX_ADAPTER_CAP_INTERNAL_PORT is not set in the adapter’s
capabilities flags for a particular ethernet device, the service function
temporarily enqueues mbufs to an event buffer before batch enqueuing these
to the event device. If the buffer fills up, the service function stops
dequeuing packets from the ethernet device. The application may want to
monitor the buffer fill level and instruct the service function to selectively
enqueue packets to the event device. The application may also use some other
criteria to decide which packets should enter the event device even when
the event buffer fill level is low. The
rte_event_eth_rx_adapter_cb_register() function allows the application
to register a callback that selects which packets to enqueue to the event
device.
15.2.1.14. Rx event vectorization
The event devices, ethernet device pairs which support the capability
RTE_EVENT_ETH_RX_ADAPTER_CAP_EVENT_VECTOR can aggregate packets based on
flow characteristics and generate a rte_event containing rte_event_vector
whose event type is either RTE_EVENT_TYPE_ETHDEV_VECTOR or
RTE_EVENT_TYPE_ETH_RX_ADAPTER_VECTOR.
The maximum, minimum vector sizes and timeouts vary based on the device
capability and can be queried using
rte_event_eth_rx_adapter_vector_limits_get.
The Rx adapter additionally might include useful data such as ethernet device
port and queue identifier in the rte_event_vector::port and
rte_event_vector::queue and mark rte_event_vector::attr_valid as true.
The aggregation size and timeout are configurable at a queue level by setting
rte_event_eth_rx_adapter_queue_conf::vector_sz,
rte_event_eth_rx_adapter_queue_conf::vector_timeout_ns and
rte_event_eth_rx_adapter_queue_conf::vector_mp when adding queues using
rte_event_eth_rx_adapter_queue_add.
A loop processing rte_event_vector containing mbufs is shown below.
event = rte_event_dequeue_burst(event_dev, event_port, &event,
1, 0);
if (!event)
continue;
switch (ev.event_type) {
case RTE_EVENT_TYPE_ETH_RX_ADAPTER_VECTOR:
case RTE_EVENT_TYPE_ETHDEV_VECTOR:
struct rte_mbuf **mbufs;
mbufs = (struct rte_mbuf **)ev[i].vec->mbufs;
for (i = 0; i < ev.vec->nb_elem; i++) {
/* Process each mbuf. */
break;
default:
/* Handle other event_types. */
15.2.1.15. Rx event vectorization for SW Rx adapter
For SW based event vectorization, i.e., when the
RTE_EVENT_ETH_RX_ADAPTER_CAP_INTERNAL_PORT is not set in the adapter’s
capabilities flags for a particular ethernet device, the service function
creates a single event vector flow for all the mbufs arriving on the given
Rx queue.
The 20-bit event flow identifier is set to 12-bits of Rx queue identifier
and 8-bits of ethernet device identifier.
Flow identifier is formatted as follows:
19 12,11 0
+---------+--------------+
| port_id | queue_id |
+---------+--------------+
