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);
93 static inline uint64_t
94 processed_pkts(struct test_pipeline *t)
101 total = t->tx_service.processed_pkts;
103 for (i = 0; i < t->nb_workers; i++)
104 total += t->worker[i].processed_pkts;
110 pipeline_launch_lcores(struct evt_test *test, struct evt_options *opt,
111 int (*worker)(void *))
114 struct test_pipeline *t = evt_test_priv(test);
118 RTE_LCORE_FOREACH_SLAVE(lcore_id) {
119 if (!(opt->wlcores[lcore_id]))
122 ret = rte_eal_remote_launch(worker,
123 &t->worker[port_idx], lcore_id);
125 evt_err("failed to launch worker %d", lcore_id);
131 uint64_t perf_cycles = rte_get_timer_cycles();
132 const uint64_t perf_sample = rte_get_timer_hz();
134 static float total_mpps;
135 static uint64_t samples;
137 uint64_t prev_pkts = 0;
139 while (t->done == false) {
140 const uint64_t new_cycles = rte_get_timer_cycles();
142 if ((new_cycles - perf_cycles) > perf_sample) {
143 const uint64_t curr_pkts = processed_pkts(t);
145 float mpps = (float)(curr_pkts - prev_pkts)/1000000;
147 prev_pkts = curr_pkts;
148 perf_cycles = new_cycles;
151 printf(CLGRN"\r%.3f mpps avg %.3f mpps"CLNRM,
152 mpps, total_mpps/samples);
161 pipeline_opt_check(struct evt_options *opt, uint64_t nb_queues)
165 * N worker + 1 master
169 if (!rte_eth_dev_count()) {
170 evt_err("test needs minimum 1 ethernet dev");
174 if (rte_lcore_count() < lcores) {
175 evt_err("test need minimum %d lcores", lcores);
179 /* Validate worker lcores */
180 if (evt_lcores_has_overlap(opt->wlcores, rte_get_master_lcore())) {
181 evt_err("worker lcores overlaps with master lcore");
184 if (evt_has_disabled_lcore(opt->wlcores)) {
185 evt_err("one or more workers lcores are not enabled");
188 if (!evt_has_active_lcore(opt->wlcores)) {
189 evt_err("minimum one worker is required");
193 if (nb_queues > EVT_MAX_QUEUES) {
194 evt_err("number of queues exceeds %d", EVT_MAX_QUEUES);
197 if (pipeline_nb_event_ports(opt) > EVT_MAX_PORTS) {
198 evt_err("number of ports exceeds %d", EVT_MAX_PORTS);
202 if (evt_has_invalid_stage(opt))
205 if (evt_has_invalid_sched_type(opt))
211 #define NB_RX_DESC 128
212 #define NB_TX_DESC 512
214 pipeline_ethdev_setup(struct evt_test *test, struct evt_options *opt)
217 uint8_t nb_queues = 1;
218 uint8_t mt_state = 0;
219 struct test_pipeline *t = evt_test_priv(test);
220 struct rte_eth_rxconf rx_conf;
221 struct rte_eth_conf port_conf = {
223 .mq_mode = ETH_MQ_RX_RSS,
224 .max_rx_pkt_len = ETHER_MAX_LEN,
225 .offloads = DEV_RX_OFFLOAD_CRC_STRIP,
226 .ignore_offload_bitfield = 1,
231 .rss_hf = ETH_RSS_IP,
237 if (!rte_eth_dev_count()) {
238 evt_err("No ethernet ports found.\n");
242 for (i = 0; i < rte_eth_dev_count(); i++) {
243 struct rte_eth_dev_info dev_info;
245 memset(&dev_info, 0, sizeof(struct rte_eth_dev_info));
246 rte_eth_dev_info_get(i, &dev_info);
247 mt_state = !(dev_info.tx_offload_capa &
248 DEV_TX_OFFLOAD_MT_LOCKFREE);
249 rx_conf = dev_info.default_rxconf;
250 rx_conf.offloads = port_conf.rxmode.offloads;
252 if (rte_eth_dev_configure(i, nb_queues, nb_queues,
255 evt_err("Failed to configure eth port [%d]\n", i);
259 if (rte_eth_rx_queue_setup(i, 0, NB_RX_DESC,
260 rte_socket_id(), &rx_conf, t->pool) < 0) {
261 evt_err("Failed to setup eth port [%d] rx_queue: %d.\n",
265 if (rte_eth_tx_queue_setup(i, 0, NB_TX_DESC,
266 rte_socket_id(), NULL) < 0) {
267 evt_err("Failed to setup eth port [%d] tx_queue: %d.\n",
272 t->mt_unsafe |= mt_state;
273 t->tx_service.tx_buf[i] =
274 rte_malloc(NULL, RTE_ETH_TX_BUFFER_SIZE(BURST_SIZE), 0);
275 if (t->tx_service.tx_buf[i] == NULL)
276 rte_panic("Unable to allocate Tx buffer memory.");
277 rte_eth_promiscuous_enable(i);
284 pipeline_event_port_setup(struct evt_test *test, struct evt_options *opt,
285 uint8_t *queue_arr, uint8_t nb_queues,
286 const struct rte_event_port_conf p_conf)
291 struct test_pipeline *t = evt_test_priv(test);
294 /* setup one port per worker, linking to all queues */
295 for (port = 0; port < evt_nr_active_lcores(opt->wlcores); port++) {
296 struct worker_data *w = &t->worker[port];
298 w->dev_id = opt->dev_id;
301 w->processed_pkts = 0;
303 ret = rte_event_port_setup(opt->dev_id, port, &p_conf);
305 evt_err("failed to setup port %d", port);
309 if (queue_arr == NULL) {
310 if (rte_event_port_link(opt->dev_id, port, NULL, NULL,
314 for (i = 0; i < nb_queues; i++) {
315 if (rte_event_port_link(opt->dev_id, port,
316 &queue_arr[i], NULL, 1) != 1)
325 evt_err("failed to link all queues to port %d", port);
330 pipeline_event_rx_adapter_setup(struct evt_options *opt, uint8_t stride,
331 struct rte_event_port_conf prod_conf)
335 struct rte_event_eth_rx_adapter_queue_conf queue_conf;
337 memset(&queue_conf, 0,
338 sizeof(struct rte_event_eth_rx_adapter_queue_conf));
339 queue_conf.ev.sched_type = opt->sched_type_list[0];
340 for (prod = 0; prod < rte_eth_dev_count(); prod++) {
343 ret = rte_event_eth_rx_adapter_caps_get(opt->dev_id,
346 evt_err("failed to get event rx adapter[%d]"
351 queue_conf.ev.queue_id = prod * stride;
352 ret = rte_event_eth_rx_adapter_create(prod, opt->dev_id,
355 evt_err("failed to create rx adapter[%d]", prod);
358 ret = rte_event_eth_rx_adapter_queue_add(prod, prod, -1,
361 evt_err("failed to add rx queues to adapter[%d]", prod);
365 if (!(cap & RTE_EVENT_ETH_RX_ADAPTER_CAP_INTERNAL_PORT)) {
368 rte_event_eth_rx_adapter_service_id_get(prod,
370 ret = evt_service_setup(service_id);
372 evt_err("Failed to setup service core"
373 " for Rx adapter\n");
378 ret = rte_eth_dev_start(prod);
380 evt_err("Ethernet dev [%d] failed to start."
381 " Using synthetic producer", prod);
385 ret = rte_event_eth_rx_adapter_start(prod);
387 evt_err("Rx adapter[%d] start failed", prod);
390 printf("%s: Port[%d] using Rx adapter[%d] started\n", __func__,
398 pipeline_event_tx_service_setup(struct evt_test *test, struct evt_options *opt,
399 uint8_t tx_queue_id, uint8_t tx_port_id,
400 const struct rte_event_port_conf p_conf)
403 struct rte_service_spec serv;
404 struct test_pipeline *t = evt_test_priv(test);
405 struct tx_service_data *tx = &t->tx_service;
407 ret = rte_event_port_setup(opt->dev_id, tx_port_id, &p_conf);
409 evt_err("failed to setup port %d", tx_port_id);
413 if (rte_event_port_link(opt->dev_id, tx_port_id, &tx_queue_id,
415 evt_err("failed to link queues to port %d", tx_port_id);
419 tx->dev_id = opt->dev_id;
420 tx->queue_id = tx_queue_id;
421 tx->port_id = tx_port_id;
422 tx->nb_ethports = rte_eth_dev_count();
425 /* Register Tx service */
426 memset(&serv, 0, sizeof(struct rte_service_spec));
427 snprintf(serv.name, sizeof(serv.name), "Tx_service");
429 if (evt_has_burst_mode(opt->dev_id))
430 serv.callback = pipeline_event_tx_burst_service_func;
432 serv.callback = pipeline_event_tx_service_func;
434 serv.callback_userdata = (void *)tx;
435 ret = rte_service_component_register(&serv, &tx->service_id);
437 evt_err("failed to register Tx service");
441 ret = evt_service_setup(tx->service_id);
443 evt_err("Failed to setup service core for Tx service\n");
447 rte_service_runstate_set(tx->service_id, 1);
454 pipeline_ethdev_destroy(struct evt_test *test, struct evt_options *opt)
459 struct test_pipeline *t = evt_test_priv(test);
462 rte_service_component_runstate_set(t->tx_service.service_id, 0);
463 rte_service_runstate_set(t->tx_service.service_id, 0);
464 rte_service_component_unregister(t->tx_service.service_id);
467 for (i = 0; i < rte_eth_dev_count(); i++) {
468 rte_event_eth_rx_adapter_stop(i);
470 rte_eth_dev_close(i);
475 pipeline_eventdev_destroy(struct evt_test *test, struct evt_options *opt)
479 rte_event_dev_stop(opt->dev_id);
480 rte_event_dev_close(opt->dev_id);
484 pipeline_mempool_setup(struct evt_test *test, struct evt_options *opt)
486 struct test_pipeline *t = evt_test_priv(test);
488 t->pool = rte_pktmbuf_pool_create(test->name, /* mempool name */
489 opt->pool_sz, /* number of elements*/
492 RTE_MBUF_DEFAULT_BUF_SIZE,
493 opt->socket_id); /* flags */
495 if (t->pool == NULL) {
496 evt_err("failed to create mempool");
504 pipeline_mempool_destroy(struct evt_test *test, struct evt_options *opt)
507 struct test_pipeline *t = evt_test_priv(test);
509 rte_mempool_free(t->pool);
513 pipeline_test_setup(struct evt_test *test, struct evt_options *opt)
517 test_pipeline = rte_zmalloc_socket(test->name,
518 sizeof(struct test_pipeline), RTE_CACHE_LINE_SIZE,
520 if (test_pipeline == NULL) {
521 evt_err("failed to allocate test_pipeline memory");
524 test->test_priv = test_pipeline;
526 struct test_pipeline *t = evt_test_priv(test);
528 t->nb_workers = evt_nr_active_lcores(opt->wlcores);
529 t->outstand_pkts = opt->nb_pkts * evt_nr_active_lcores(opt->wlcores);
531 t->nb_flows = opt->nb_flows;
532 t->result = EVT_TEST_FAILED;
534 opt->prod_type = EVT_PROD_TYPE_ETH_RX_ADPTR;
535 memcpy(t->sched_type_list, opt->sched_type_list,
536 sizeof(opt->sched_type_list));
543 pipeline_test_destroy(struct evt_test *test, struct evt_options *opt)
547 rte_free(test->test_priv);