From 54f17843a887131fb638a2b788fc35c7e7c57d99 Mon Sep 17 00:00:00 2001 From: =?utf8?q?Mattias=20R=C3=B6nnblom?= Date: Mon, 1 Nov 2021 19:40:14 +0100 Subject: [PATCH] eventdev: add port maintenance API MIME-Version: 1.0 Content-Type: text/plain; charset=utf8 Content-Transfer-Encoding: 8bit Extend Eventdev API to allow for event devices which require various forms of internal processing to happen, even when events are not enqueued to or dequeued from a port. Signed-off-by: Mattias Rönnblom Acked-by: Jerin Jacob Tested-by: Richard Eklycke Tested-by: Liron Himi --- lib/eventdev/eventdev_pmd.h | 2 + lib/eventdev/eventdev_private.c | 9 ++++ lib/eventdev/eventdev_trace_points.c | 3 ++ lib/eventdev/rte_eventdev.h | 79 ++++++++++++++++++++++++++++ lib/eventdev/rte_eventdev_core.h | 5 ++ lib/eventdev/rte_eventdev_trace_fp.h | 8 +++ 6 files changed, 106 insertions(+) diff --git a/lib/eventdev/eventdev_pmd.h b/lib/eventdev/eventdev_pmd.h index 3ba49d1fd4..4787df7ba0 100644 --- a/lib/eventdev/eventdev_pmd.h +++ b/lib/eventdev/eventdev_pmd.h @@ -164,6 +164,8 @@ struct rte_eventdev { /**< Pointer to PMD dequeue function. */ event_dequeue_burst_t dequeue_burst; /**< Pointer to PMD dequeue burst function. */ + event_maintain_t maintain; + /**< Pointer to PMD port maintenance function. */ event_tx_adapter_enqueue_t txa_enqueue_same_dest; /**< Pointer to PMD eth Tx adapter burst enqueue function with * events destined to same Eth port & Tx queue. diff --git a/lib/eventdev/eventdev_private.c b/lib/eventdev/eventdev_private.c index 9084833847..1d3d9d357e 100644 --- a/lib/eventdev/eventdev_private.c +++ b/lib/eventdev/eventdev_private.c @@ -44,6 +44,13 @@ dummy_event_dequeue_burst(__rte_unused void *port, return 0; } +static void +dummy_event_maintain(__rte_unused void *port, __rte_unused int op) +{ + RTE_EDEV_LOG_ERR( + "maintenance requested for unconfigured event device"); +} + static uint16_t dummy_event_tx_adapter_enqueue(__rte_unused void *port, __rte_unused struct rte_event ev[], @@ -85,6 +92,7 @@ event_dev_fp_ops_reset(struct rte_event_fp_ops *fp_op) .enqueue_forward_burst = dummy_event_enqueue_burst, .dequeue = dummy_event_dequeue, .dequeue_burst = dummy_event_dequeue_burst, + .maintain = dummy_event_maintain, .txa_enqueue = dummy_event_tx_adapter_enqueue, .txa_enqueue_same_dest = dummy_event_tx_adapter_enqueue_same_dest, @@ -105,6 +113,7 @@ event_dev_fp_ops_set(struct rte_event_fp_ops *fp_op, fp_op->enqueue_forward_burst = dev->enqueue_forward_burst; fp_op->dequeue = dev->dequeue; fp_op->dequeue_burst = dev->dequeue_burst; + fp_op->maintain = dev->maintain; fp_op->txa_enqueue = dev->txa_enqueue; fp_op->txa_enqueue_same_dest = dev->txa_enqueue_same_dest; fp_op->ca_enqueue = dev->ca_enqueue; diff --git a/lib/eventdev/eventdev_trace_points.c b/lib/eventdev/eventdev_trace_points.c index 237d9383fd..de6b1f4417 100644 --- a/lib/eventdev/eventdev_trace_points.c +++ b/lib/eventdev/eventdev_trace_points.c @@ -37,6 +37,9 @@ RTE_TRACE_POINT_REGISTER(rte_eventdev_trace_enq_burst, RTE_TRACE_POINT_REGISTER(rte_eventdev_trace_deq_burst, lib.eventdev.deq.burst) +RTE_TRACE_POINT_REGISTER(rte_eventdev_trace_maintain, + lib.eventdev.maintain) + /* Eventdev Rx adapter trace points */ RTE_TRACE_POINT_REGISTER(rte_eventdev_trace_eth_rx_adapter_create, lib.eventdev.rx.adapter.create) diff --git a/lib/eventdev/rte_eventdev.h b/lib/eventdev/rte_eventdev.h index 0abed56bef..e026486ca5 100644 --- a/lib/eventdev/rte_eventdev.h +++ b/lib/eventdev/rte_eventdev.h @@ -299,6 +299,15 @@ struct rte_event; * the content of this field is implementation dependent. */ +#define RTE_EVENT_DEV_CAP_REQUIRES_MAINT (1ULL << 10) +/**< Event device requires calls to rte_event_maintain() during + * periods when neither rte_event_dequeue_burst() nor + * rte_event_enqueue_burst() are called on a port. This will allow the + * event device to perform internal processing, such as flushing + * buffered events, return credits to a global pool, or process + * signaling related to load balancing. + */ + /* Event device priority levels */ #define RTE_EVENT_DEV_PRIORITY_HIGHEST 0 /**< Highest priority expressed across eventdev subsystem @@ -2063,6 +2072,76 @@ rte_event_dequeue_burst(uint8_t dev_id, uint8_t port_id, struct rte_event ev[], timeout_ticks); } +#define RTE_EVENT_DEV_MAINT_OP_FLUSH (1 << 0) +/**< Force an immediately flush of any buffered events in the port, + * potentially at the cost of additional overhead. + * + * @see rte_event_maintain() + */ + +/** + * Maintain an event device. + * + * This function is only relevant for event devices which have the + * @ref RTE_EVENT_DEV_CAP_REQUIRES_MAINT flag set. Such devices + * require an application thread using a particular port to + * periodically call rte_event_maintain() on that port during periods + * which it is neither attempting to enqueue events to nor dequeue + * events from the port. rte_event_maintain() is a low-overhead + * function and should be called at a high rate (e.g., in the + * application's poll loop). + * + * No port may be left unmaintained. + * + * At the application thread's convenience, rte_event_maintain() may + * (but is not required to) be called even during periods when enqueue + * or dequeue functions are being called, at the cost of a slight + * increase in overhead. + * + * rte_event_maintain() may be called on event devices which haven't + * set @ref RTE_EVENT_DEV_CAP_REQUIRES_MAINT flag, in which case it is + * a no-operation. + * + * @param dev_id + * The identifier of the device. + * @param port_id + * The identifier of the event port. + * @param op + * 0, or @ref RTE_EVENT_DEV_MAINT_OP_FLUSH. + * @return + * - 0 on success. + * - -EINVAL if *dev_id*, *port_id*, or *op* is invalid. + * + * @see RTE_EVENT_DEV_CAP_REQUIRES_MAINT + */ +__rte_experimental +static inline int +rte_event_maintain(uint8_t dev_id, uint8_t port_id, int op) +{ + const struct rte_event_fp_ops *fp_ops; + void *port; + + fp_ops = &rte_event_fp_ops[dev_id]; + port = fp_ops->data[port_id]; +#ifdef RTE_LIBRTE_EVENTDEV_DEBUG + if (dev_id >= RTE_EVENT_MAX_DEVS || + port_id >= RTE_EVENT_MAX_PORTS_PER_DEV) + return -EINVAL; + + if (port == NULL) + return -EINVAL; + + if (op & (~RTE_EVENT_DEV_MAINT_OP_FLUSH)) + return -EINVAL; +#endif + rte_eventdev_trace_maintain(dev_id, port_id, op); + + if (fp_ops->maintain != NULL) + fp_ops->maintain(port, op); + + return 0; +} + #ifdef __cplusplus } #endif diff --git a/lib/eventdev/rte_eventdev_core.h b/lib/eventdev/rte_eventdev_core.h index 61d5ebdc44..c328bdbc82 100644 --- a/lib/eventdev/rte_eventdev_core.h +++ b/lib/eventdev/rte_eventdev_core.h @@ -29,6 +29,9 @@ typedef uint16_t (*event_dequeue_burst_t)(void *port, struct rte_event ev[], uint64_t timeout_ticks); /**< @internal Dequeue burst of events from port of a device */ +typedef void (*event_maintain_t)(void *port, int op); +/**< @internal Maintains a port */ + typedef uint16_t (*event_tx_adapter_enqueue_t)(void *port, struct rte_event ev[], uint16_t nb_events); @@ -54,6 +57,8 @@ struct rte_event_fp_ops { /**< PMD dequeue function. */ event_dequeue_burst_t dequeue_burst; /**< PMD dequeue burst function. */ + event_maintain_t maintain; + /**< PMD port maintenance function. */ event_tx_adapter_enqueue_t txa_enqueue; /**< PMD Tx adapter enqueue function. */ event_tx_adapter_enqueue_t txa_enqueue_same_dest; diff --git a/lib/eventdev/rte_eventdev_trace_fp.h b/lib/eventdev/rte_eventdev_trace_fp.h index 5639e0b83a..af2172d2a5 100644 --- a/lib/eventdev/rte_eventdev_trace_fp.h +++ b/lib/eventdev/rte_eventdev_trace_fp.h @@ -38,6 +38,14 @@ RTE_TRACE_POINT_FP( rte_trace_point_emit_ptr(enq_mode_cb); ) +RTE_TRACE_POINT_FP( + rte_eventdev_trace_maintain, + RTE_TRACE_POINT_ARGS(uint8_t dev_id, uint8_t port_id, int op), + rte_trace_point_emit_u8(dev_id); + rte_trace_point_emit_u8(port_id); + rte_trace_point_emit_int(op); +) + RTE_TRACE_POINT_FP( rte_eventdev_trace_eth_tx_adapter_enqueue, RTE_TRACE_POINT_ARGS(uint8_t dev_id, uint8_t port_id, void *ev_table, -- 2.39.5