2 * SPDX-License-Identifier: BSD-3-Clause
3 * Copyright 2017 Cavium, Inc.
6 #include "test_pipeline_common.h"
9 pipeline_event_tx_burst_service_func(void *args)
13 struct tx_service_data *tx = args;
14 const uint8_t dev = tx->dev_id;
15 const uint8_t port = tx->port_id;
16 struct rte_event ev[BURST_SIZE + 1];
18 uint16_t nb_rx = rte_event_dequeue_burst(dev, port, ev, BURST_SIZE, 0);
21 for (i = 0; i < tx->nb_ethports; i++)
22 rte_eth_tx_buffer_flush(i, 0, tx->tx_buf[i]);
26 for (i = 0; i < nb_rx; i++) {
27 struct rte_mbuf *m = ev[i].mbuf;
28 rte_eth_tx_buffer(m->port, 0, tx->tx_buf[m->port], m);
30 tx->processed_pkts += nb_rx;
36 pipeline_event_tx_service_func(void *args)
40 struct tx_service_data *tx = args;
41 const uint8_t dev = tx->dev_id;
42 const uint8_t port = tx->port_id;
45 uint16_t nb_rx = rte_event_dequeue_burst(dev, port, &ev, 1, 0);
48 for (i = 0; i < tx->nb_ethports; i++)
49 rte_eth_tx_buffer_flush(i, 0, tx->tx_buf[i]);
53 struct rte_mbuf *m = ev.mbuf;
54 rte_eth_tx_buffer(m->port, 0, tx->tx_buf[m->port], m);
61 pipeline_test_result(struct evt_test *test, struct evt_options *opt)
66 struct test_pipeline *t = evt_test_priv(test);
68 printf("Packet distribution across worker cores :\n");
69 for (i = 0; i < t->nb_workers; i++)
70 total += t->worker[i].processed_pkts;
71 for (i = 0; i < t->nb_workers; i++)
72 printf("Worker %d packets: "CLGRN"%"PRIx64" "CLNRM"percentage:"
73 CLGRN" %3.2f\n"CLNRM, i,
74 t->worker[i].processed_pkts,
75 (((double)t->worker[i].processed_pkts)/total)
81 pipeline_opt_dump(struct evt_options *opt, uint8_t nb_queues)
83 evt_dump("nb_worker_lcores", "%d", evt_nr_active_lcores(opt->wlcores));
84 evt_dump_worker_lcores(opt);
85 evt_dump_nb_stages(opt);
86 evt_dump("nb_evdev_ports", "%d", pipeline_nb_event_ports(opt));
87 evt_dump("nb_evdev_queues", "%d", nb_queues);
88 evt_dump_queue_priority(opt);
89 evt_dump_sched_type_list(opt);
90 evt_dump_producer_type(opt);
94 pipeline_opt_check(struct evt_options *opt, uint64_t nb_queues)
102 if (!rte_eth_dev_count()) {
103 evt_err("test needs minimum 1 ethernet dev");
107 if (rte_lcore_count() < lcores) {
108 evt_err("test need minimum %d lcores", lcores);
112 /* Validate worker lcores */
113 if (evt_lcores_has_overlap(opt->wlcores, rte_get_master_lcore())) {
114 evt_err("worker lcores overlaps with master lcore");
117 if (evt_has_disabled_lcore(opt->wlcores)) {
118 evt_err("one or more workers lcores are not enabled");
121 if (!evt_has_active_lcore(opt->wlcores)) {
122 evt_err("minimum one worker is required");
126 if (nb_queues > EVT_MAX_QUEUES) {
127 evt_err("number of queues exceeds %d", EVT_MAX_QUEUES);
130 if (pipeline_nb_event_ports(opt) > EVT_MAX_PORTS) {
131 evt_err("number of ports exceeds %d", EVT_MAX_PORTS);
135 if (evt_has_invalid_stage(opt))
138 if (evt_has_invalid_sched_type(opt))
144 #define NB_RX_DESC 128
145 #define NB_TX_DESC 512
147 pipeline_ethdev_setup(struct evt_test *test, struct evt_options *opt)
150 uint8_t nb_queues = 1;
151 uint8_t mt_state = 0;
152 struct test_pipeline *t = evt_test_priv(test);
153 struct rte_eth_rxconf rx_conf;
154 struct rte_eth_conf port_conf = {
156 .mq_mode = ETH_MQ_RX_RSS,
157 .max_rx_pkt_len = ETHER_MAX_LEN,
158 .offloads = DEV_RX_OFFLOAD_CRC_STRIP,
159 .ignore_offload_bitfield = 1,
164 .rss_hf = ETH_RSS_IP,
170 if (!rte_eth_dev_count()) {
171 evt_err("No ethernet ports found.\n");
175 for (i = 0; i < rte_eth_dev_count(); i++) {
176 struct rte_eth_dev_info dev_info;
178 memset(&dev_info, 0, sizeof(struct rte_eth_dev_info));
179 rte_eth_dev_info_get(i, &dev_info);
180 mt_state = !(dev_info.tx_offload_capa &
181 DEV_TX_OFFLOAD_MT_LOCKFREE);
182 rx_conf = dev_info.default_rxconf;
183 rx_conf.offloads = port_conf.rxmode.offloads;
185 if (rte_eth_dev_configure(i, nb_queues, nb_queues,
188 evt_err("Failed to configure eth port [%d]\n", i);
192 if (rte_eth_rx_queue_setup(i, 0, NB_RX_DESC,
193 rte_socket_id(), &rx_conf, t->pool) < 0) {
194 evt_err("Failed to setup eth port [%d] rx_queue: %d.\n",
198 if (rte_eth_tx_queue_setup(i, 0, NB_TX_DESC,
199 rte_socket_id(), NULL) < 0) {
200 evt_err("Failed to setup eth port [%d] tx_queue: %d.\n",
205 t->mt_unsafe |= mt_state;
206 t->tx_service.tx_buf[i] =
207 rte_malloc(NULL, RTE_ETH_TX_BUFFER_SIZE(BURST_SIZE), 0);
208 if (t->tx_service.tx_buf[i] == NULL)
209 rte_panic("Unable to allocate Tx buffer memory.");
210 rte_eth_promiscuous_enable(i);
217 pipeline_event_port_setup(struct evt_test *test, struct evt_options *opt,
218 uint8_t *queue_arr, uint8_t nb_queues,
219 const struct rte_event_port_conf p_conf)
224 struct test_pipeline *t = evt_test_priv(test);
227 /* setup one port per worker, linking to all queues */
228 for (port = 0; port < evt_nr_active_lcores(opt->wlcores); port++) {
229 struct worker_data *w = &t->worker[port];
231 w->dev_id = opt->dev_id;
234 w->processed_pkts = 0;
236 ret = rte_event_port_setup(opt->dev_id, port, &p_conf);
238 evt_err("failed to setup port %d", port);
242 if (queue_arr == NULL) {
243 if (rte_event_port_link(opt->dev_id, port, NULL, NULL,
247 for (i = 0; i < nb_queues; i++) {
248 if (rte_event_port_link(opt->dev_id, port,
249 &queue_arr[i], NULL, 1) != 1)
258 evt_err("failed to link all queues to port %d", port);
263 pipeline_event_rx_adapter_setup(struct evt_options *opt, uint8_t stride,
264 struct rte_event_port_conf prod_conf)
268 struct rte_event_eth_rx_adapter_queue_conf queue_conf;
270 memset(&queue_conf, 0,
271 sizeof(struct rte_event_eth_rx_adapter_queue_conf));
272 queue_conf.ev.sched_type = opt->sched_type_list[0];
273 for (prod = 0; prod < rte_eth_dev_count(); prod++) {
276 ret = rte_event_eth_rx_adapter_caps_get(opt->dev_id,
279 evt_err("failed to get event rx adapter[%d]"
284 queue_conf.ev.queue_id = prod * stride;
285 ret = rte_event_eth_rx_adapter_create(prod, opt->dev_id,
288 evt_err("failed to create rx adapter[%d]", prod);
291 ret = rte_event_eth_rx_adapter_queue_add(prod, prod, -1,
294 evt_err("failed to add rx queues to adapter[%d]", prod);
298 if (!(cap & RTE_EVENT_ETH_RX_ADAPTER_CAP_INTERNAL_PORT)) {
301 rte_event_eth_rx_adapter_service_id_get(prod,
303 ret = evt_service_setup(service_id);
305 evt_err("Failed to setup service core"
306 " for Rx adapter\n");
311 ret = rte_eth_dev_start(prod);
313 evt_err("Ethernet dev [%d] failed to start."
314 " Using synthetic producer", prod);
318 ret = rte_event_eth_rx_adapter_start(prod);
320 evt_err("Rx adapter[%d] start failed", prod);
323 printf("%s: Port[%d] using Rx adapter[%d] started\n", __func__,
331 pipeline_event_tx_service_setup(struct evt_test *test, struct evt_options *opt,
332 uint8_t tx_queue_id, uint8_t tx_port_id,
333 const struct rte_event_port_conf p_conf)
336 struct rte_service_spec serv;
337 struct test_pipeline *t = evt_test_priv(test);
338 struct tx_service_data *tx = &t->tx_service;
340 ret = rte_event_port_setup(opt->dev_id, tx_port_id, &p_conf);
342 evt_err("failed to setup port %d", tx_port_id);
346 if (rte_event_port_link(opt->dev_id, tx_port_id, &tx_queue_id,
348 evt_err("failed to link queues to port %d", tx_port_id);
352 tx->dev_id = opt->dev_id;
353 tx->queue_id = tx_queue_id;
354 tx->port_id = tx_port_id;
355 tx->nb_ethports = rte_eth_dev_count();
358 /* Register Tx service */
359 memset(&serv, 0, sizeof(struct rte_service_spec));
360 snprintf(serv.name, sizeof(serv.name), "Tx_service");
362 if (evt_has_burst_mode(opt->dev_id))
363 serv.callback = pipeline_event_tx_burst_service_func;
365 serv.callback = pipeline_event_tx_service_func;
367 serv.callback_userdata = (void *)tx;
368 ret = rte_service_component_register(&serv, &tx->service_id);
370 evt_err("failed to register Tx service");
374 ret = evt_service_setup(tx->service_id);
376 evt_err("Failed to setup service core for Tx service\n");
380 rte_service_runstate_set(tx->service_id, 1);
387 pipeline_ethdev_destroy(struct evt_test *test, struct evt_options *opt)
392 struct test_pipeline *t = evt_test_priv(test);
395 rte_service_component_runstate_set(t->tx_service.service_id, 0);
396 rte_service_runstate_set(t->tx_service.service_id, 0);
397 rte_service_component_unregister(t->tx_service.service_id);
400 for (i = 0; i < rte_eth_dev_count(); i++) {
401 rte_event_eth_rx_adapter_stop(i);
403 rte_eth_dev_close(i);
408 pipeline_eventdev_destroy(struct evt_test *test, struct evt_options *opt)
412 rte_event_dev_stop(opt->dev_id);
413 rte_event_dev_close(opt->dev_id);
417 pipeline_mempool_setup(struct evt_test *test, struct evt_options *opt)
419 struct test_pipeline *t = evt_test_priv(test);
421 t->pool = rte_pktmbuf_pool_create(test->name, /* mempool name */
422 opt->pool_sz, /* number of elements*/
425 RTE_MBUF_DEFAULT_BUF_SIZE,
426 opt->socket_id); /* flags */
428 if (t->pool == NULL) {
429 evt_err("failed to create mempool");
437 pipeline_mempool_destroy(struct evt_test *test, struct evt_options *opt)
440 struct test_pipeline *t = evt_test_priv(test);
442 rte_mempool_free(t->pool);
446 pipeline_test_setup(struct evt_test *test, struct evt_options *opt)
450 test_pipeline = rte_zmalloc_socket(test->name,
451 sizeof(struct test_pipeline), RTE_CACHE_LINE_SIZE,
453 if (test_pipeline == NULL) {
454 evt_err("failed to allocate test_pipeline memory");
457 test->test_priv = test_pipeline;
459 struct test_pipeline *t = evt_test_priv(test);
461 t->nb_workers = evt_nr_active_lcores(opt->wlcores);
462 t->outstand_pkts = opt->nb_pkts * evt_nr_active_lcores(opt->wlcores);
464 t->nb_flows = opt->nb_flows;
465 t->result = EVT_TEST_FAILED;
467 opt->prod_type = EVT_PROD_TYPE_ETH_RX_ADPTR;
468 memcpy(t->sched_type_list, opt->sched_type_list,
469 sizeof(opt->sched_type_list));
476 pipeline_test_destroy(struct evt_test *test, struct evt_options *opt)
480 rte_free(test->test_priv);