1 /* SPDX-License-Identifier: BSD-3-Clause
2 * Copyright(c) 2018 Ericsson AB
7 #include <rte_cycles.h>
8 #include <eventdev_pmd.h>
9 #include <eventdev_pmd_vdev.h>
10 #include <rte_random.h>
11 #include <rte_ring_elem.h>
13 #include "dsw_evdev.h"
15 #define EVENTDEV_NAME_DSW_PMD event_dsw
18 dsw_port_setup(struct rte_eventdev *dev, uint8_t port_id,
19 const struct rte_event_port_conf *conf)
21 struct dsw_evdev *dsw = dsw_pmd_priv(dev);
22 struct dsw_port *port;
23 struct rte_event_ring *in_ring;
24 struct rte_ring *ctl_in_ring;
25 char ring_name[RTE_RING_NAMESIZE];
27 port = &dsw->ports[port_id];
29 *port = (struct dsw_port) {
32 .dequeue_depth = conf->dequeue_depth,
33 .enqueue_depth = conf->enqueue_depth,
34 .new_event_threshold = conf->new_event_threshold
37 snprintf(ring_name, sizeof(ring_name), "dsw%d_p%u", dev->data->dev_id,
40 in_ring = rte_event_ring_create(ring_name, DSW_IN_RING_SIZE,
42 RING_F_SC_DEQ|RING_F_EXACT_SZ);
47 snprintf(ring_name, sizeof(ring_name), "dswctl%d_p%u",
48 dev->data->dev_id, port_id);
50 ctl_in_ring = rte_ring_create_elem(ring_name,
51 sizeof(struct dsw_ctl_msg),
54 RING_F_SC_DEQ|RING_F_EXACT_SZ);
56 if (ctl_in_ring == NULL) {
57 rte_event_ring_free(in_ring);
61 port->in_ring = in_ring;
62 port->ctl_in_ring = ctl_in_ring;
64 port->load_update_interval =
65 (DSW_LOAD_UPDATE_INTERVAL * rte_get_timer_hz()) / US_PER_S;
67 port->migration_interval =
68 (DSW_MIGRATION_INTERVAL * rte_get_timer_hz()) / US_PER_S;
70 dev->data->ports[port_id] = port;
76 dsw_port_def_conf(struct rte_eventdev *dev __rte_unused,
77 uint8_t port_id __rte_unused,
78 struct rte_event_port_conf *port_conf)
80 *port_conf = (struct rte_event_port_conf) {
81 .new_event_threshold = 1024,
82 .dequeue_depth = DSW_MAX_PORT_DEQUEUE_DEPTH / 4,
83 .enqueue_depth = DSW_MAX_PORT_ENQUEUE_DEPTH / 4
88 dsw_port_release(void *p)
90 struct dsw_port *port = p;
92 rte_event_ring_free(port->in_ring);
93 rte_ring_free(port->ctl_in_ring);
97 dsw_queue_setup(struct rte_eventdev *dev, uint8_t queue_id,
98 const struct rte_event_queue_conf *conf)
100 struct dsw_evdev *dsw = dsw_pmd_priv(dev);
101 struct dsw_queue *queue = &dsw->queues[queue_id];
103 if (RTE_EVENT_QUEUE_CFG_ALL_TYPES & conf->event_queue_cfg)
106 /* SINGLE_LINK is better off treated as TYPE_ATOMIC, since it
107 * avoid the "fake" TYPE_PARALLEL flow_id assignment. Since
108 * the queue will only have a single serving port, no
109 * migration will ever happen, so the extra TYPE_ATOMIC
110 * migration overhead is avoided.
112 if (RTE_EVENT_QUEUE_CFG_SINGLE_LINK & conf->event_queue_cfg)
113 queue->schedule_type = RTE_SCHED_TYPE_ATOMIC;
115 if (conf->schedule_type == RTE_SCHED_TYPE_ORDERED)
117 /* atomic or parallel */
118 queue->schedule_type = conf->schedule_type;
121 queue->num_serving_ports = 0;
127 dsw_queue_def_conf(struct rte_eventdev *dev __rte_unused,
128 uint8_t queue_id __rte_unused,
129 struct rte_event_queue_conf *queue_conf)
131 *queue_conf = (struct rte_event_queue_conf) {
132 .nb_atomic_flows = 4096,
133 .schedule_type = RTE_SCHED_TYPE_ATOMIC,
134 .priority = RTE_EVENT_DEV_PRIORITY_NORMAL
139 dsw_queue_release(struct rte_eventdev *dev __rte_unused,
140 uint8_t queue_id __rte_unused)
145 queue_add_port(struct dsw_queue *queue, uint16_t port_id)
147 queue->serving_ports[queue->num_serving_ports] = port_id;
148 queue->num_serving_ports++;
152 queue_remove_port(struct dsw_queue *queue, uint16_t port_id)
156 for (i = 0; i < queue->num_serving_ports; i++)
157 if (queue->serving_ports[i] == port_id) {
158 uint16_t last_idx = queue->num_serving_ports - 1;
160 queue->serving_ports[i] =
161 queue->serving_ports[last_idx];
162 queue->num_serving_ports--;
169 dsw_port_link_unlink(struct rte_eventdev *dev, void *port,
170 const uint8_t queues[], uint16_t num, bool link)
172 struct dsw_evdev *dsw = dsw_pmd_priv(dev);
173 struct dsw_port *p = port;
177 for (i = 0; i < num; i++) {
178 uint8_t qid = queues[i];
179 struct dsw_queue *q = &dsw->queues[qid];
181 queue_add_port(q, p->id);
184 bool removed = queue_remove_port(q, p->id);
194 dsw_port_link(struct rte_eventdev *dev, void *port, const uint8_t queues[],
195 const uint8_t priorities[] __rte_unused, uint16_t num)
197 return dsw_port_link_unlink(dev, port, queues, num, true);
201 dsw_port_unlink(struct rte_eventdev *dev, void *port, uint8_t queues[],
204 return dsw_port_link_unlink(dev, port, queues, num, false);
208 dsw_info_get(struct rte_eventdev *dev __rte_unused,
209 struct rte_event_dev_info *info)
211 *info = (struct rte_event_dev_info) {
212 .driver_name = DSW_PMD_NAME,
213 .max_event_queues = DSW_MAX_QUEUES,
214 .max_event_queue_flows = DSW_MAX_FLOWS,
215 .max_event_queue_priority_levels = 1,
216 .max_event_priority_levels = 1,
217 .max_event_ports = DSW_MAX_PORTS,
218 .max_event_port_dequeue_depth = DSW_MAX_PORT_DEQUEUE_DEPTH,
219 .max_event_port_enqueue_depth = DSW_MAX_PORT_ENQUEUE_DEPTH,
220 .max_num_events = DSW_MAX_EVENTS,
221 .event_dev_cap = RTE_EVENT_DEV_CAP_BURST_MODE|
222 RTE_EVENT_DEV_CAP_DISTRIBUTED_SCHED|
223 RTE_EVENT_DEV_CAP_NONSEQ_MODE|
224 RTE_EVENT_DEV_CAP_MULTIPLE_QUEUE_PORT|
225 RTE_EVENT_DEV_CAP_CARRY_FLOW_ID
230 dsw_configure(const struct rte_eventdev *dev)
232 struct dsw_evdev *dsw = dsw_pmd_priv(dev);
233 const struct rte_event_dev_config *conf = &dev->data->dev_conf;
234 int32_t min_max_in_flight;
236 dsw->num_ports = conf->nb_event_ports;
237 dsw->num_queues = conf->nb_event_queues;
239 /* Avoid a situation where consumer ports are holding all the
240 * credits, without making use of them.
242 min_max_in_flight = conf->nb_event_ports * DSW_PORT_MAX_CREDITS;
244 dsw->max_inflight = RTE_MAX(conf->nb_events_limit, min_max_in_flight);
251 initial_flow_to_port_assignment(struct dsw_evdev *dsw)
254 for (queue_id = 0; queue_id < dsw->num_queues; queue_id++) {
255 struct dsw_queue *queue = &dsw->queues[queue_id];
257 for (flow_hash = 0; flow_hash < DSW_MAX_FLOWS; flow_hash++) {
259 rte_rand() % queue->num_serving_ports;
261 queue->serving_ports[port_idx];
262 dsw->queues[queue_id].flow_to_port_map[flow_hash] =
269 dsw_start(struct rte_eventdev *dev)
271 struct dsw_evdev *dsw = dsw_pmd_priv(dev);
275 dsw->credits_on_loan = 0;
277 initial_flow_to_port_assignment(dsw);
279 now = rte_get_timer_cycles();
280 for (i = 0; i < dsw->num_ports; i++) {
281 dsw->ports[i].measurement_start = now;
282 dsw->ports[i].busy_start = now;
289 dsw_port_drain_buf(uint8_t dev_id, struct rte_event *buf, uint16_t buf_len,
290 eventdev_stop_flush_t flush, void *flush_arg)
294 for (i = 0; i < buf_len; i++)
295 flush(dev_id, buf[i], flush_arg);
299 dsw_port_drain_paused(uint8_t dev_id, struct dsw_port *port,
300 eventdev_stop_flush_t flush, void *flush_arg)
302 dsw_port_drain_buf(dev_id, port->paused_events, port->paused_events_len,
307 dsw_port_drain_out(uint8_t dev_id, struct dsw_evdev *dsw, struct dsw_port *port,
308 eventdev_stop_flush_t flush, void *flush_arg)
312 for (dport_id = 0; dport_id < dsw->num_ports; dport_id++)
313 if (dport_id != port->id)
314 dsw_port_drain_buf(dev_id, port->out_buffer[dport_id],
315 port->out_buffer_len[dport_id],
320 dsw_port_drain_in_ring(uint8_t dev_id, struct dsw_port *port,
321 eventdev_stop_flush_t flush, void *flush_arg)
325 while (rte_event_ring_dequeue_burst(port->in_ring, &ev, 1, NULL))
326 flush(dev_id, ev, flush_arg);
330 dsw_drain(uint8_t dev_id, struct dsw_evdev *dsw,
331 eventdev_stop_flush_t flush, void *flush_arg)
338 for (port_id = 0; port_id < dsw->num_ports; port_id++) {
339 struct dsw_port *port = &dsw->ports[port_id];
341 dsw_port_drain_out(dev_id, dsw, port, flush, flush_arg);
342 dsw_port_drain_paused(dev_id, port, flush, flush_arg);
343 dsw_port_drain_in_ring(dev_id, port, flush, flush_arg);
348 dsw_stop(struct rte_eventdev *dev)
350 struct dsw_evdev *dsw = dsw_pmd_priv(dev);
352 eventdev_stop_flush_t flush;
355 dev_id = dev->data->dev_id;
356 flush = dev->dev_ops->dev_stop_flush;
357 flush_arg = dev->data->dev_stop_flush_arg;
359 dsw_drain(dev_id, dsw, flush, flush_arg);
363 dsw_close(struct rte_eventdev *dev)
365 struct dsw_evdev *dsw = dsw_pmd_priv(dev);
374 dsw_eth_rx_adapter_caps_get(const struct rte_eventdev *dev __rte_unused,
375 const struct rte_eth_dev *eth_dev __rte_unused,
378 *caps = RTE_EVENT_ETH_RX_ADAPTER_SW_CAP;
383 dsw_timer_adapter_caps_get(const struct rte_eventdev *dev __rte_unused,
384 uint64_t flags __rte_unused, uint32_t *caps,
385 const struct rte_event_timer_adapter_ops **ops)
393 dsw_crypto_adapter_caps_get(const struct rte_eventdev *dev __rte_unused,
394 const struct rte_cryptodev *cdev __rte_unused,
397 *caps = RTE_EVENT_CRYPTO_ADAPTER_SW_CAP;
401 static struct eventdev_ops dsw_evdev_ops = {
402 .port_setup = dsw_port_setup,
403 .port_def_conf = dsw_port_def_conf,
404 .port_release = dsw_port_release,
405 .queue_setup = dsw_queue_setup,
406 .queue_def_conf = dsw_queue_def_conf,
407 .queue_release = dsw_queue_release,
408 .port_link = dsw_port_link,
409 .port_unlink = dsw_port_unlink,
410 .dev_infos_get = dsw_info_get,
411 .dev_configure = dsw_configure,
412 .dev_start = dsw_start,
413 .dev_stop = dsw_stop,
414 .dev_close = dsw_close,
415 .eth_rx_adapter_caps_get = dsw_eth_rx_adapter_caps_get,
416 .timer_adapter_caps_get = dsw_timer_adapter_caps_get,
417 .crypto_adapter_caps_get = dsw_crypto_adapter_caps_get,
418 .xstats_get = dsw_xstats_get,
419 .xstats_get_names = dsw_xstats_get_names,
420 .xstats_get_by_name = dsw_xstats_get_by_name
424 dsw_probe(struct rte_vdev_device *vdev)
427 struct rte_eventdev *dev;
428 struct dsw_evdev *dsw;
430 name = rte_vdev_device_name(vdev);
432 dev = rte_event_pmd_vdev_init(name, sizeof(struct dsw_evdev),
437 dev->dev_ops = &dsw_evdev_ops;
438 dev->enqueue = dsw_event_enqueue;
439 dev->enqueue_burst = dsw_event_enqueue_burst;
440 dev->enqueue_new_burst = dsw_event_enqueue_new_burst;
441 dev->enqueue_forward_burst = dsw_event_enqueue_forward_burst;
442 dev->dequeue = dsw_event_dequeue;
443 dev->dequeue_burst = dsw_event_dequeue_burst;
445 if (rte_eal_process_type() != RTE_PROC_PRIMARY)
448 dsw = dev->data->dev_private;
449 dsw->data = dev->data;
451 event_dev_probing_finish(dev);
456 dsw_remove(struct rte_vdev_device *vdev)
460 name = rte_vdev_device_name(vdev);
464 return rte_event_pmd_vdev_uninit(name);
467 static struct rte_vdev_driver evdev_dsw_pmd_drv = {
472 RTE_PMD_REGISTER_VDEV(EVENTDEV_NAME_DSW_PMD, evdev_dsw_pmd_drv);