1 /* SPDX-License-Identifier: BSD-3-Clause
2 * Copyright(c) 2010-2017 Intel Corporation
12 #include <rte_ethdev.h>
13 #include <rte_cycles.h>
14 #include <rte_malloc.h>
15 #include <rte_debug.h>
16 #include <rte_prefetch.h>
17 #include <rte_distributor.h>
18 #include <rte_pause.h>
19 #include <rte_power.h>
21 #define RX_RING_SIZE 1024
22 #define TX_RING_SIZE 1024
23 #define NUM_MBUFS ((64*1024)-1)
24 #define MBUF_CACHE_SIZE 128
26 #define SCHED_RX_RING_SZ 8192
27 #define SCHED_TX_RING_SZ 65536
28 #define BURST_SIZE_TX 32
30 #define RTE_LOGTYPE_DISTRAPP RTE_LOGTYPE_USER1
32 #define ANSI_COLOR_RED "\x1b[31m"
33 #define ANSI_COLOR_RESET "\x1b[0m"
35 /* mask of enabled ports */
36 static uint32_t enabled_port_mask;
37 volatile uint8_t quit_signal;
38 volatile uint8_t quit_signal_rx;
39 volatile uint8_t quit_signal_dist;
40 volatile uint8_t quit_signal_work;
41 unsigned int power_lib_initialised;
43 static volatile struct app_stats {
46 uint64_t returned_pkts;
47 uint64_t enqueued_pkts;
48 uint64_t enqdrop_pkts;
49 } rx __rte_cache_aligned;
50 int pad1 __rte_cache_aligned;
56 uint64_t enqdrop_pkts;
57 } dist __rte_cache_aligned;
58 int pad2 __rte_cache_aligned;
61 uint64_t dequeue_pkts;
63 uint64_t enqdrop_pkts;
64 } tx __rte_cache_aligned;
65 int pad3 __rte_cache_aligned;
67 uint64_t worker_pkts[64] __rte_cache_aligned;
69 int pad4 __rte_cache_aligned;
71 uint64_t worker_bursts[64][8] __rte_cache_aligned;
73 int pad5 __rte_cache_aligned;
75 uint64_t port_rx_pkts[64] __rte_cache_aligned;
76 uint64_t port_tx_pkts[64] __rte_cache_aligned;
79 struct app_stats prev_app_stats;
81 static const struct rte_eth_conf port_conf_default = {
83 .mq_mode = ETH_MQ_RX_RSS,
84 .max_rx_pkt_len = RTE_ETHER_MAX_LEN,
87 .mq_mode = ETH_MQ_TX_NONE,
91 .rss_hf = ETH_RSS_IP | ETH_RSS_UDP |
92 ETH_RSS_TCP | ETH_RSS_SCTP,
97 struct output_buffer {
99 struct rte_mbuf *mbufs[BURST_SIZE];
102 static void print_stats(void);
105 * Initialises a given port using global settings and with the rx buffers
106 * coming from the mbuf_pool passed as parameter
109 port_init(uint16_t port, struct rte_mempool *mbuf_pool)
111 struct rte_eth_conf port_conf = port_conf_default;
112 const uint16_t rxRings = 1, txRings = rte_lcore_count() - 1;
115 uint16_t nb_rxd = RX_RING_SIZE;
116 uint16_t nb_txd = TX_RING_SIZE;
117 struct rte_eth_dev_info dev_info;
118 struct rte_eth_txconf txconf;
120 if (!rte_eth_dev_is_valid_port(port))
123 retval = rte_eth_dev_info_get(port, &dev_info);
125 printf("Error during getting device (port %u) info: %s\n",
126 port, strerror(-retval));
130 if (dev_info.tx_offload_capa & DEV_TX_OFFLOAD_MBUF_FAST_FREE)
131 port_conf.txmode.offloads |=
132 DEV_TX_OFFLOAD_MBUF_FAST_FREE;
134 port_conf.rx_adv_conf.rss_conf.rss_hf &=
135 dev_info.flow_type_rss_offloads;
136 if (port_conf.rx_adv_conf.rss_conf.rss_hf !=
137 port_conf_default.rx_adv_conf.rss_conf.rss_hf) {
138 printf("Port %u modified RSS hash function based on hardware support,"
139 "requested:%#"PRIx64" configured:%#"PRIx64"\n",
141 port_conf_default.rx_adv_conf.rss_conf.rss_hf,
142 port_conf.rx_adv_conf.rss_conf.rss_hf);
145 retval = rte_eth_dev_configure(port, rxRings, txRings, &port_conf);
149 retval = rte_eth_dev_adjust_nb_rx_tx_desc(port, &nb_rxd, &nb_txd);
153 for (q = 0; q < rxRings; q++) {
154 retval = rte_eth_rx_queue_setup(port, q, nb_rxd,
155 rte_eth_dev_socket_id(port),
161 txconf = dev_info.default_txconf;
162 txconf.offloads = port_conf.txmode.offloads;
163 for (q = 0; q < txRings; q++) {
164 retval = rte_eth_tx_queue_setup(port, q, nb_txd,
165 rte_eth_dev_socket_id(port),
171 retval = rte_eth_dev_start(port);
175 struct rte_eth_link link;
177 retval = rte_eth_link_get_nowait(port, &link);
179 printf("Failed link get (port %u): %s\n",
180 port, rte_strerror(-retval));
182 } else if (link.link_status)
185 printf("Waiting for Link up on port %"PRIu16"\n", port);
187 } while (!link.link_status);
189 if (!link.link_status) {
190 printf("Link down on port %"PRIu16"\n", port);
194 struct rte_ether_addr addr;
195 retval = rte_eth_macaddr_get(port, &addr);
197 printf("Failed to get MAC address (port %u): %s\n",
198 port, rte_strerror(-retval));
202 printf("Port %u MAC: %02"PRIx8" %02"PRIx8" %02"PRIx8
203 " %02"PRIx8" %02"PRIx8" %02"PRIx8"\n",
204 port, RTE_ETHER_ADDR_BYTES(&addr));
206 retval = rte_eth_promiscuous_enable(port);
213 struct lcore_params {
215 struct rte_distributor *d;
216 struct rte_ring *rx_dist_ring;
217 struct rte_ring *dist_tx_ring;
218 struct rte_mempool *mem_pool;
222 lcore_rx(struct lcore_params *p)
224 const uint16_t nb_ports = rte_eth_dev_count_avail();
225 const int socket_id = rte_socket_id();
227 struct rte_mbuf *bufs[BURST_SIZE*2];
229 RTE_ETH_FOREACH_DEV(port) {
230 /* skip ports that are not enabled */
231 if ((enabled_port_mask & (1 << port)) == 0)
234 if (rte_eth_dev_socket_id(port) > 0 &&
235 rte_eth_dev_socket_id(port) != socket_id)
236 printf("WARNING, port %u is on remote NUMA node to "
237 "RX thread.\n\tPerformance will not "
238 "be optimal.\n", port);
241 printf("\nCore %u doing packet RX.\n", rte_lcore_id());
243 while (!quit_signal_rx) {
245 /* skip ports that are not enabled */
246 if ((enabled_port_mask & (1 << port)) == 0) {
247 if (++port == nb_ports)
251 const uint16_t nb_rx = rte_eth_rx_burst(port, 0, bufs,
253 if (unlikely(nb_rx == 0)) {
254 if (++port == nb_ports)
258 app_stats.rx.rx_pkts += nb_rx;
261 * You can run the distributor on the rx core with this code. Returned
262 * packets are then send straight to the tx core.
265 rte_distributor_process(d, bufs, nb_rx);
266 const uint16_t nb_ret = rte_distributor_returned_pktsd,
269 app_stats.rx.returned_pkts += nb_ret;
270 if (unlikely(nb_ret == 0)) {
271 if (++port == nb_ports)
276 struct rte_ring *tx_ring = p->dist_tx_ring;
277 uint16_t sent = rte_ring_enqueue_burst(tx_ring,
278 (void *)bufs, nb_ret, NULL);
280 uint16_t nb_ret = nb_rx;
282 * Swap the following two lines if you want the rx traffic
283 * to go directly to tx, no distribution.
285 struct rte_ring *out_ring = p->rx_dist_ring;
286 /* struct rte_ring *out_ring = p->dist_tx_ring; */
288 uint16_t sent = rte_ring_enqueue_burst(out_ring,
289 (void *)bufs, nb_ret, NULL);
292 app_stats.rx.enqueued_pkts += sent;
293 if (unlikely(sent < nb_ret)) {
294 app_stats.rx.enqdrop_pkts += nb_ret - sent;
295 RTE_LOG_DP(DEBUG, DISTRAPP,
296 "%s:Packet loss due to full ring\n", __func__);
297 while (sent < nb_ret)
298 rte_pktmbuf_free(bufs[sent++]);
300 if (++port == nb_ports)
303 if (power_lib_initialised)
304 rte_power_exit(rte_lcore_id());
305 /* set worker & tx threads quit flag */
306 printf("\nCore %u exiting rx task.\n", rte_lcore_id());
312 flush_one_port(struct output_buffer *outbuf, uint8_t outp)
314 unsigned int nb_tx = rte_eth_tx_burst(outp, 0,
315 outbuf->mbufs, outbuf->count);
316 app_stats.tx.tx_pkts += outbuf->count;
318 if (unlikely(nb_tx < outbuf->count)) {
319 app_stats.tx.enqdrop_pkts += outbuf->count - nb_tx;
321 rte_pktmbuf_free(outbuf->mbufs[nb_tx]);
322 } while (++nb_tx < outbuf->count);
328 flush_all_ports(struct output_buffer *tx_buffers)
332 RTE_ETH_FOREACH_DEV(outp) {
333 /* skip ports that are not enabled */
334 if ((enabled_port_mask & (1 << outp)) == 0)
337 if (tx_buffers[outp].count == 0)
340 flush_one_port(&tx_buffers[outp], outp);
347 lcore_distributor(struct lcore_params *p)
349 struct rte_ring *in_r = p->rx_dist_ring;
350 struct rte_ring *out_r = p->dist_tx_ring;
351 struct rte_mbuf *bufs[BURST_SIZE * 4];
352 struct rte_distributor *d = p->d;
354 printf("\nCore %u acting as distributor core.\n", rte_lcore_id());
355 while (!quit_signal_dist) {
356 const uint16_t nb_rx = rte_ring_dequeue_burst(in_r,
357 (void *)bufs, BURST_SIZE*1, NULL);
359 app_stats.dist.in_pkts += nb_rx;
361 /* Distribute the packets */
362 rte_distributor_process(d, bufs, nb_rx);
364 const uint16_t nb_ret =
365 rte_distributor_returned_pkts(d,
368 if (unlikely(nb_ret == 0))
370 app_stats.dist.ret_pkts += nb_ret;
372 uint16_t sent = rte_ring_enqueue_burst(out_r,
373 (void *)bufs, nb_ret, NULL);
374 app_stats.dist.sent_pkts += sent;
375 if (unlikely(sent < nb_ret)) {
376 app_stats.dist.enqdrop_pkts += nb_ret - sent;
377 RTE_LOG(DEBUG, DISTRAPP,
378 "%s:Packet loss due to full out ring\n",
380 while (sent < nb_ret)
381 rte_pktmbuf_free(bufs[sent++]);
385 printf("\nCore %u exiting distributor task.\n", rte_lcore_id());
386 quit_signal_work = 1;
387 if (power_lib_initialised)
388 rte_power_exit(rte_lcore_id());
389 rte_distributor_flush(d);
390 /* Unblock any returns so workers can exit */
391 rte_distributor_clear_returns(d);
398 lcore_tx(struct rte_ring *in_r)
400 static struct output_buffer tx_buffers[RTE_MAX_ETHPORTS];
401 const int socket_id = rte_socket_id();
404 RTE_ETH_FOREACH_DEV(port) {
405 /* skip ports that are not enabled */
406 if ((enabled_port_mask & (1 << port)) == 0)
409 if (rte_eth_dev_socket_id(port) > 0 &&
410 rte_eth_dev_socket_id(port) != socket_id)
411 printf("WARNING, port %u is on remote NUMA node to "
412 "TX thread.\n\tPerformance will not "
413 "be optimal.\n", port);
416 printf("\nCore %u doing packet TX.\n", rte_lcore_id());
417 while (!quit_signal) {
419 RTE_ETH_FOREACH_DEV(port) {
420 /* skip ports that are not enabled */
421 if ((enabled_port_mask & (1 << port)) == 0)
424 struct rte_mbuf *bufs[BURST_SIZE_TX];
425 const uint16_t nb_rx = rte_ring_dequeue_burst(in_r,
426 (void *)bufs, BURST_SIZE_TX, NULL);
427 app_stats.tx.dequeue_pkts += nb_rx;
429 /* if we get no traffic, flush anything we have */
430 if (unlikely(nb_rx == 0)) {
431 flush_all_ports(tx_buffers);
435 /* for traffic we receive, queue it up for transmit */
437 rte_prefetch_non_temporal((void *)bufs[0]);
438 rte_prefetch_non_temporal((void *)bufs[1]);
439 rte_prefetch_non_temporal((void *)bufs[2]);
440 for (i = 0; i < nb_rx; i++) {
441 struct output_buffer *outbuf;
443 rte_prefetch_non_temporal((void *)bufs[i + 3]);
445 * workers should update in_port to hold the
448 outp = bufs[i]->port;
449 /* skip ports that are not enabled */
450 if ((enabled_port_mask & (1 << outp)) == 0)
453 outbuf = &tx_buffers[outp];
454 outbuf->mbufs[outbuf->count++] = bufs[i];
455 if (outbuf->count == BURST_SIZE_TX)
456 flush_one_port(outbuf, outp);
460 if (power_lib_initialised)
461 rte_power_exit(rte_lcore_id());
462 printf("\nCore %u exiting tx task.\n", rte_lcore_id());
467 int_handler(int sig_num)
469 printf("Exiting on signal %d\n", sig_num);
470 /* set quit flag for rx thread to exit */
471 quit_signal_dist = 1;
477 struct rte_eth_stats eth_stats;
479 const unsigned int num_workers = rte_lcore_count() - 4;
481 RTE_ETH_FOREACH_DEV(i) {
482 rte_eth_stats_get(i, ð_stats);
483 app_stats.port_rx_pkts[i] = eth_stats.ipackets;
484 app_stats.port_tx_pkts[i] = eth_stats.opackets;
487 printf("\n\nRX Thread:\n");
488 RTE_ETH_FOREACH_DEV(i) {
489 printf("Port %u Pktsin : %5.2f\n", i,
490 (app_stats.port_rx_pkts[i] -
491 prev_app_stats.port_rx_pkts[i])/1000000.0);
492 prev_app_stats.port_rx_pkts[i] = app_stats.port_rx_pkts[i];
494 printf(" - Received: %5.2f\n",
495 (app_stats.rx.rx_pkts -
496 prev_app_stats.rx.rx_pkts)/1000000.0);
497 printf(" - Returned: %5.2f\n",
498 (app_stats.rx.returned_pkts -
499 prev_app_stats.rx.returned_pkts)/1000000.0);
500 printf(" - Enqueued: %5.2f\n",
501 (app_stats.rx.enqueued_pkts -
502 prev_app_stats.rx.enqueued_pkts)/1000000.0);
503 printf(" - Dropped: %s%5.2f%s\n", ANSI_COLOR_RED,
504 (app_stats.rx.enqdrop_pkts -
505 prev_app_stats.rx.enqdrop_pkts)/1000000.0,
508 printf("Distributor thread:\n");
509 printf(" - In: %5.2f\n",
510 (app_stats.dist.in_pkts -
511 prev_app_stats.dist.in_pkts)/1000000.0);
512 printf(" - Returned: %5.2f\n",
513 (app_stats.dist.ret_pkts -
514 prev_app_stats.dist.ret_pkts)/1000000.0);
515 printf(" - Sent: %5.2f\n",
516 (app_stats.dist.sent_pkts -
517 prev_app_stats.dist.sent_pkts)/1000000.0);
518 printf(" - Dropped %s%5.2f%s\n", ANSI_COLOR_RED,
519 (app_stats.dist.enqdrop_pkts -
520 prev_app_stats.dist.enqdrop_pkts)/1000000.0,
523 printf("TX thread:\n");
524 printf(" - Dequeued: %5.2f\n",
525 (app_stats.tx.dequeue_pkts -
526 prev_app_stats.tx.dequeue_pkts)/1000000.0);
527 RTE_ETH_FOREACH_DEV(i) {
528 printf("Port %u Pktsout: %5.2f\n",
529 i, (app_stats.port_tx_pkts[i] -
530 prev_app_stats.port_tx_pkts[i])/1000000.0);
531 prev_app_stats.port_tx_pkts[i] = app_stats.port_tx_pkts[i];
533 printf(" - Transmitted: %5.2f\n",
534 (app_stats.tx.tx_pkts -
535 prev_app_stats.tx.tx_pkts)/1000000.0);
536 printf(" - Dropped: %s%5.2f%s\n", ANSI_COLOR_RED,
537 (app_stats.tx.enqdrop_pkts -
538 prev_app_stats.tx.enqdrop_pkts)/1000000.0,
541 prev_app_stats.rx.rx_pkts = app_stats.rx.rx_pkts;
542 prev_app_stats.rx.returned_pkts = app_stats.rx.returned_pkts;
543 prev_app_stats.rx.enqueued_pkts = app_stats.rx.enqueued_pkts;
544 prev_app_stats.rx.enqdrop_pkts = app_stats.rx.enqdrop_pkts;
545 prev_app_stats.dist.in_pkts = app_stats.dist.in_pkts;
546 prev_app_stats.dist.ret_pkts = app_stats.dist.ret_pkts;
547 prev_app_stats.dist.sent_pkts = app_stats.dist.sent_pkts;
548 prev_app_stats.dist.enqdrop_pkts = app_stats.dist.enqdrop_pkts;
549 prev_app_stats.tx.dequeue_pkts = app_stats.tx.dequeue_pkts;
550 prev_app_stats.tx.tx_pkts = app_stats.tx.tx_pkts;
551 prev_app_stats.tx.enqdrop_pkts = app_stats.tx.enqdrop_pkts;
553 for (i = 0; i < num_workers; i++) {
554 printf("Worker %02u Pkts: %5.2f. Bursts(1-8): ", i,
555 (app_stats.worker_pkts[i] -
556 prev_app_stats.worker_pkts[i])/1000000.0);
557 for (j = 0; j < 8; j++) {
558 printf("%"PRIu64" ", app_stats.worker_bursts[i][j]);
559 app_stats.worker_bursts[i][j] = 0;
562 prev_app_stats.worker_pkts[i] = app_stats.worker_pkts[i];
567 lcore_worker(struct lcore_params *p)
569 struct rte_distributor *d = p->d;
570 const unsigned id = p->worker_id;
571 unsigned int num = 0;
575 * for single port, xor_val will be zero so we won't modify the output
576 * port, otherwise we send traffic from 0 to 1, 2 to 3, and vice versa
578 const unsigned xor_val = (rte_eth_dev_count_avail() > 1);
579 struct rte_mbuf *buf[8] __rte_cache_aligned;
581 for (i = 0; i < 8; i++)
584 app_stats.worker_pkts[p->worker_id] = 1;
586 printf("\nCore %u acting as worker core.\n", rte_lcore_id());
587 while (!quit_signal_work) {
588 num = rte_distributor_get_pkt(d, id, buf, buf, num);
589 /* Do a little bit of work for each packet */
590 for (i = 0; i < num; i++) {
591 uint64_t t = rte_rdtsc()+100;
593 while (rte_rdtsc() < t)
595 buf[i]->port ^= xor_val;
598 app_stats.worker_pkts[p->worker_id] += num;
600 app_stats.worker_bursts[p->worker_id][num-1]++;
602 if (power_lib_initialised)
603 rte_power_exit(rte_lcore_id());
609 init_power_library(void)
611 int ret = 0, lcore_id;
612 RTE_LCORE_FOREACH_WORKER(lcore_id) {
613 /* init power management library */
614 ret = rte_power_init(lcore_id);
617 "Library initialization failed on core %u\n",
620 * Return on first failure, we'll fall back
621 * to non-power operation
631 print_usage(const char *prgname)
633 printf("%s [EAL options] -- -p PORTMASK\n"
634 " -p PORTMASK: hexadecimal bitmask of ports to configure\n",
639 parse_portmask(const char *portmask)
644 /* parse hexadecimal string */
645 pm = strtoul(portmask, &end, 16);
646 if ((portmask[0] == '\0') || (end == NULL) || (*end != '\0'))
652 /* Parse the argument given in the command line of the application */
654 parse_args(int argc, char **argv)
659 char *prgname = argv[0];
660 static struct option lgopts[] = {
666 while ((opt = getopt_long(argc, argvopt, "p:",
667 lgopts, &option_index)) != EOF) {
672 enabled_port_mask = parse_portmask(optarg);
673 if (enabled_port_mask == 0) {
674 printf("invalid portmask\n");
675 print_usage(prgname);
681 print_usage(prgname);
687 print_usage(prgname);
691 argv[optind-1] = prgname;
693 optind = 1; /* reset getopt lib */
697 /* Main function, does initialization and calls the per-lcore functions */
699 main(int argc, char *argv[])
701 struct rte_mempool *mbuf_pool;
702 struct rte_distributor *d;
703 struct rte_ring *dist_tx_ring;
704 struct rte_ring *rx_dist_ring;
705 struct rte_power_core_capabilities lcore_cap;
706 unsigned int lcore_id, worker_id = 0;
707 int distr_core_id = -1, rx_core_id = -1, tx_core_id = -1;
710 uint16_t nb_ports_available;
713 /* catch ctrl-c so we can print on exit */
714 signal(SIGINT, int_handler);
717 int ret = rte_eal_init(argc, argv);
719 rte_exit(EXIT_FAILURE, "Error with EAL initialization\n");
723 /* parse application arguments (after the EAL ones) */
724 ret = parse_args(argc, argv);
726 rte_exit(EXIT_FAILURE, "Invalid distributor parameters\n");
728 if (rte_lcore_count() < 5)
729 rte_exit(EXIT_FAILURE, "Error, This application needs at "
730 "least 5 logical cores to run:\n"
731 "1 lcore for stats (can be core 0)\n"
732 "1 lcore for packet RX\n"
733 "1 lcore for distribution\n"
734 "1 lcore for packet TX\n"
735 "and at least 1 lcore for worker threads\n");
737 if (init_power_library() == 0)
738 power_lib_initialised = 1;
740 nb_ports = rte_eth_dev_count_avail();
742 rte_exit(EXIT_FAILURE, "Error: no ethernet ports detected\n");
743 if (nb_ports != 1 && (nb_ports & 1))
744 rte_exit(EXIT_FAILURE, "Error: number of ports must be even, except "
745 "when using a single port\n");
747 mbuf_pool = rte_pktmbuf_pool_create("MBUF_POOL",
748 NUM_MBUFS * nb_ports, MBUF_CACHE_SIZE, 0,
749 RTE_MBUF_DEFAULT_BUF_SIZE, rte_socket_id());
750 if (mbuf_pool == NULL)
751 rte_exit(EXIT_FAILURE, "Cannot create mbuf pool\n");
752 nb_ports_available = nb_ports;
754 /* initialize all ports */
755 RTE_ETH_FOREACH_DEV(portid) {
756 /* skip ports that are not enabled */
757 if ((enabled_port_mask & (1 << portid)) == 0) {
758 printf("\nSkipping disabled port %d\n", portid);
759 nb_ports_available--;
763 printf("Initializing port %u... done\n", portid);
765 if (port_init(portid, mbuf_pool) != 0)
766 rte_exit(EXIT_FAILURE, "Cannot initialize port %u\n",
770 if (!nb_ports_available) {
771 rte_exit(EXIT_FAILURE,
772 "All available ports are disabled. Please set portmask.\n");
775 d = rte_distributor_create("PKT_DIST", rte_socket_id(),
776 rte_lcore_count() - 4,
779 rte_exit(EXIT_FAILURE, "Cannot create distributor\n");
782 * scheduler ring is read by the transmitter core, and written to
785 dist_tx_ring = rte_ring_create("Output_ring", SCHED_TX_RING_SZ,
786 rte_socket_id(), RING_F_SC_DEQ | RING_F_SP_ENQ);
787 if (dist_tx_ring == NULL)
788 rte_exit(EXIT_FAILURE, "Cannot create output ring\n");
790 rx_dist_ring = rte_ring_create("Input_ring", SCHED_RX_RING_SZ,
791 rte_socket_id(), RING_F_SC_DEQ | RING_F_SP_ENQ);
792 if (rx_dist_ring == NULL)
793 rte_exit(EXIT_FAILURE, "Cannot create output ring\n");
795 if (power_lib_initialised) {
797 * Here we'll pre-assign lcore ids to the rx, tx and
798 * distributor workloads if there's higher frequency
799 * on those cores e.g. if Turbo Boost is enabled.
800 * It's also worth mentioning that it will assign cores in a
801 * specific order, so that if there's less than three
802 * available, the higher frequency cores will go to the
803 * distributor first, then rx, then tx.
805 RTE_LCORE_FOREACH_WORKER(lcore_id) {
807 rte_power_get_capabilities(lcore_id, &lcore_cap);
809 if (lcore_cap.priority != 1)
812 if (distr_core_id < 0) {
813 distr_core_id = lcore_id;
814 printf("Distributor on priority core %d\n",
818 if (rx_core_id < 0) {
819 rx_core_id = lcore_id;
820 printf("Rx on priority core %d\n",
824 if (tx_core_id < 0) {
825 tx_core_id = lcore_id;
826 printf("Tx on priority core %d\n",
834 * If there's any of the key workloads left without an lcore_id
835 * after the high performing core assignment above, pre-assign
838 RTE_LCORE_FOREACH_WORKER(lcore_id) {
839 if (lcore_id == (unsigned int)distr_core_id ||
840 lcore_id == (unsigned int)rx_core_id ||
841 lcore_id == (unsigned int)tx_core_id)
843 if (distr_core_id < 0) {
844 distr_core_id = lcore_id;
845 printf("Distributor on core %d\n", lcore_id);
848 if (rx_core_id < 0) {
849 rx_core_id = lcore_id;
850 printf("Rx on core %d\n", lcore_id);
853 if (tx_core_id < 0) {
854 tx_core_id = lcore_id;
855 printf("Tx on core %d\n", lcore_id);
860 printf(" tx id %d, dist id %d, rx id %d\n",
866 * Kick off all the worker threads first, avoiding the pre-assigned
867 * lcore_ids for tx, rx and distributor workloads.
869 RTE_LCORE_FOREACH_WORKER(lcore_id) {
870 if (lcore_id == (unsigned int)distr_core_id ||
871 lcore_id == (unsigned int)rx_core_id ||
872 lcore_id == (unsigned int)tx_core_id)
874 printf("Starting thread %d as worker, lcore_id %d\n",
875 worker_id, lcore_id);
876 struct lcore_params *p =
877 rte_malloc(NULL, sizeof(*p), 0);
879 rte_panic("malloc failure\n");
880 *p = (struct lcore_params){worker_id++, d, rx_dist_ring,
881 dist_tx_ring, mbuf_pool};
883 rte_eal_remote_launch((lcore_function_t *)lcore_worker,
888 rte_eal_remote_launch((lcore_function_t *)lcore_tx,
889 dist_tx_ring, tx_core_id);
891 /* Start distributor core */
892 struct lcore_params *pd =
893 rte_malloc(NULL, sizeof(*pd), 0);
895 rte_panic("malloc failure\n");
896 *pd = (struct lcore_params){worker_id++, d,
897 rx_dist_ring, dist_tx_ring, mbuf_pool};
898 rte_eal_remote_launch(
899 (lcore_function_t *)lcore_distributor,
903 struct lcore_params *pr =
904 rte_malloc(NULL, sizeof(*pr), 0);
906 rte_panic("malloc failure\n");
907 *pr = (struct lcore_params){worker_id++, d, rx_dist_ring,
908 dist_tx_ring, mbuf_pool};
909 rte_eal_remote_launch((lcore_function_t *)lcore_rx,
912 freq = rte_get_timer_hz();
913 t = rte_rdtsc() + freq;
914 while (!quit_signal_dist) {
915 if (t < rte_rdtsc()) {
917 t = rte_rdtsc() + freq;
922 RTE_LCORE_FOREACH_WORKER(lcore_id) {
923 if (rte_eal_wait_lcore(lcore_id) < 0)
932 /* clean up the EAL */