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>
20 #define RX_RING_SIZE 512
21 #define TX_RING_SIZE 512
22 #define NUM_MBUFS ((64*1024)-1)
23 #define MBUF_CACHE_SIZE 128
25 #define SCHED_RX_RING_SZ 8192
26 #define SCHED_TX_RING_SZ 65536
27 #define BURST_SIZE_TX 32
29 #define RTE_LOGTYPE_DISTRAPP RTE_LOGTYPE_USER1
31 #define ANSI_COLOR_RED "\x1b[31m"
32 #define ANSI_COLOR_RESET "\x1b[0m"
34 /* mask of enabled ports */
35 static uint32_t enabled_port_mask;
36 volatile uint8_t quit_signal;
37 volatile uint8_t quit_signal_rx;
38 volatile uint8_t quit_signal_dist;
39 volatile uint8_t quit_signal_work;
41 static volatile struct app_stats {
44 uint64_t returned_pkts;
45 uint64_t enqueued_pkts;
46 uint64_t enqdrop_pkts;
47 } rx __rte_cache_aligned;
48 int pad1 __rte_cache_aligned;
54 uint64_t enqdrop_pkts;
55 } dist __rte_cache_aligned;
56 int pad2 __rte_cache_aligned;
59 uint64_t dequeue_pkts;
61 uint64_t enqdrop_pkts;
62 } tx __rte_cache_aligned;
63 int pad3 __rte_cache_aligned;
65 uint64_t worker_pkts[64] __rte_cache_aligned;
67 int pad4 __rte_cache_aligned;
69 uint64_t worker_bursts[64][8] __rte_cache_aligned;
71 int pad5 __rte_cache_aligned;
73 uint64_t port_rx_pkts[64] __rte_cache_aligned;
74 uint64_t port_tx_pkts[64] __rte_cache_aligned;
77 struct app_stats prev_app_stats;
79 static const struct rte_eth_conf port_conf_default = {
81 .mq_mode = ETH_MQ_RX_RSS,
82 .max_rx_pkt_len = ETHER_MAX_LEN,
83 .ignore_offload_bitfield = 1,
86 .mq_mode = ETH_MQ_TX_NONE,
90 .rss_hf = ETH_RSS_IP | ETH_RSS_UDP |
91 ETH_RSS_TCP | ETH_RSS_SCTP,
96 struct output_buffer {
98 struct rte_mbuf *mbufs[BURST_SIZE];
101 static void print_stats(void);
104 * Initialises a given port using global settings and with the rx buffers
105 * coming from the mbuf_pool passed as parameter
108 port_init(uint16_t port, struct rte_mempool *mbuf_pool)
110 struct rte_eth_conf port_conf = port_conf_default;
111 const uint16_t rxRings = 1, txRings = rte_lcore_count() - 1;
114 uint16_t nb_rxd = RX_RING_SIZE;
115 uint16_t nb_txd = TX_RING_SIZE;
116 struct rte_eth_dev_info dev_info;
117 struct rte_eth_txconf txconf;
119 if (port >= rte_eth_dev_count())
122 rte_eth_dev_info_get(port, &dev_info);
123 if (dev_info.tx_offload_capa & DEV_TX_OFFLOAD_MBUF_FAST_FREE)
124 port_conf.txmode.offloads |=
125 DEV_TX_OFFLOAD_MBUF_FAST_FREE;
127 retval = rte_eth_dev_configure(port, rxRings, txRings, &port_conf);
131 retval = rte_eth_dev_adjust_nb_rx_tx_desc(port, &nb_rxd, &nb_txd);
135 for (q = 0; q < rxRings; q++) {
136 retval = rte_eth_rx_queue_setup(port, q, nb_rxd,
137 rte_eth_dev_socket_id(port),
143 txconf = dev_info.default_txconf;
144 txconf.txq_flags = ETH_TXQ_FLAGS_IGNORE;
145 txconf.offloads = port_conf.txmode.offloads;
146 for (q = 0; q < txRings; q++) {
147 retval = rte_eth_tx_queue_setup(port, q, nb_txd,
148 rte_eth_dev_socket_id(port),
154 retval = rte_eth_dev_start(port);
158 struct rte_eth_link link;
159 rte_eth_link_get_nowait(port, &link);
160 while (!link.link_status) {
161 printf("Waiting for Link up on port %"PRIu16"\n", port);
163 rte_eth_link_get_nowait(port, &link);
166 if (!link.link_status) {
167 printf("Link down on port %"PRIu16"\n", port);
171 struct ether_addr addr;
172 rte_eth_macaddr_get(port, &addr);
173 printf("Port %u MAC: %02"PRIx8" %02"PRIx8" %02"PRIx8
174 " %02"PRIx8" %02"PRIx8" %02"PRIx8"\n",
176 addr.addr_bytes[0], addr.addr_bytes[1],
177 addr.addr_bytes[2], addr.addr_bytes[3],
178 addr.addr_bytes[4], addr.addr_bytes[5]);
180 rte_eth_promiscuous_enable(port);
185 struct lcore_params {
187 struct rte_distributor *d;
188 struct rte_ring *rx_dist_ring;
189 struct rte_ring *dist_tx_ring;
190 struct rte_mempool *mem_pool;
194 lcore_rx(struct lcore_params *p)
196 const uint16_t nb_ports = rte_eth_dev_count();
197 const int socket_id = rte_socket_id();
199 struct rte_mbuf *bufs[BURST_SIZE*2];
201 for (port = 0; port < nb_ports; port++) {
202 /* skip ports that are not enabled */
203 if ((enabled_port_mask & (1 << port)) == 0)
206 if (rte_eth_dev_socket_id(port) > 0 &&
207 rte_eth_dev_socket_id(port) != socket_id)
208 printf("WARNING, port %u is on remote NUMA node to "
209 "RX thread.\n\tPerformance will not "
210 "be optimal.\n", port);
213 printf("\nCore %u doing packet RX.\n", rte_lcore_id());
215 while (!quit_signal_rx) {
217 /* skip ports that are not enabled */
218 if ((enabled_port_mask & (1 << port)) == 0) {
219 if (++port == nb_ports)
223 const uint16_t nb_rx = rte_eth_rx_burst(port, 0, bufs,
225 if (unlikely(nb_rx == 0)) {
226 if (++port == nb_ports)
230 app_stats.rx.rx_pkts += nb_rx;
233 * You can run the distributor on the rx core with this code. Returned
234 * packets are then send straight to the tx core.
237 rte_distributor_process(d, bufs, nb_rx);
238 const uint16_t nb_ret = rte_distributor_returned_pktsd,
241 app_stats.rx.returned_pkts += nb_ret;
242 if (unlikely(nb_ret == 0)) {
243 if (++port == nb_ports)
248 struct rte_ring *tx_ring = p->dist_tx_ring;
249 uint16_t sent = rte_ring_enqueue_burst(tx_ring,
250 (void *)bufs, nb_ret, NULL);
252 uint16_t nb_ret = nb_rx;
254 * Swap the following two lines if you want the rx traffic
255 * to go directly to tx, no distribution.
257 struct rte_ring *out_ring = p->rx_dist_ring;
258 /* struct rte_ring *out_ring = p->dist_tx_ring; */
260 uint16_t sent = rte_ring_enqueue_burst(out_ring,
261 (void *)bufs, nb_ret, NULL);
264 app_stats.rx.enqueued_pkts += sent;
265 if (unlikely(sent < nb_ret)) {
266 app_stats.rx.enqdrop_pkts += nb_ret - sent;
267 RTE_LOG_DP(DEBUG, DISTRAPP,
268 "%s:Packet loss due to full ring\n", __func__);
269 while (sent < nb_ret)
270 rte_pktmbuf_free(bufs[sent++]);
272 if (++port == nb_ports)
275 /* set worker & tx threads quit flag */
276 printf("\nCore %u exiting rx task.\n", rte_lcore_id());
282 flush_one_port(struct output_buffer *outbuf, uint8_t outp)
284 unsigned int nb_tx = rte_eth_tx_burst(outp, 0,
285 outbuf->mbufs, outbuf->count);
286 app_stats.tx.tx_pkts += outbuf->count;
288 if (unlikely(nb_tx < outbuf->count)) {
289 app_stats.tx.enqdrop_pkts += outbuf->count - nb_tx;
291 rte_pktmbuf_free(outbuf->mbufs[nb_tx]);
292 } while (++nb_tx < outbuf->count);
298 flush_all_ports(struct output_buffer *tx_buffers, uint16_t nb_ports)
302 for (outp = 0; outp < nb_ports; outp++) {
303 /* skip ports that are not enabled */
304 if ((enabled_port_mask & (1 << outp)) == 0)
307 if (tx_buffers[outp].count == 0)
310 flush_one_port(&tx_buffers[outp], outp);
317 lcore_distributor(struct lcore_params *p)
319 struct rte_ring *in_r = p->rx_dist_ring;
320 struct rte_ring *out_r = p->dist_tx_ring;
321 struct rte_mbuf *bufs[BURST_SIZE * 4];
322 struct rte_distributor *d = p->d;
324 printf("\nCore %u acting as distributor core.\n", rte_lcore_id());
325 while (!quit_signal_dist) {
326 const uint16_t nb_rx = rte_ring_dequeue_burst(in_r,
327 (void *)bufs, BURST_SIZE*1, NULL);
329 app_stats.dist.in_pkts += nb_rx;
331 /* Distribute the packets */
332 rte_distributor_process(d, bufs, nb_rx);
334 const uint16_t nb_ret =
335 rte_distributor_returned_pkts(d,
338 if (unlikely(nb_ret == 0))
340 app_stats.dist.ret_pkts += nb_ret;
342 uint16_t sent = rte_ring_enqueue_burst(out_r,
343 (void *)bufs, nb_ret, NULL);
344 app_stats.dist.sent_pkts += sent;
345 if (unlikely(sent < nb_ret)) {
346 app_stats.dist.enqdrop_pkts += nb_ret - sent;
347 RTE_LOG(DEBUG, DISTRAPP,
348 "%s:Packet loss due to full out ring\n",
350 while (sent < nb_ret)
351 rte_pktmbuf_free(bufs[sent++]);
355 printf("\nCore %u exiting distributor task.\n", rte_lcore_id());
356 quit_signal_work = 1;
358 rte_distributor_flush(d);
359 /* Unblock any returns so workers can exit */
360 rte_distributor_clear_returns(d);
367 lcore_tx(struct rte_ring *in_r)
369 static struct output_buffer tx_buffers[RTE_MAX_ETHPORTS];
370 const uint16_t nb_ports = rte_eth_dev_count();
371 const int socket_id = rte_socket_id();
374 for (port = 0; port < nb_ports; port++) {
375 /* skip ports that are not enabled */
376 if ((enabled_port_mask & (1 << port)) == 0)
379 if (rte_eth_dev_socket_id(port) > 0 &&
380 rte_eth_dev_socket_id(port) != socket_id)
381 printf("WARNING, port %u is on remote NUMA node to "
382 "TX thread.\n\tPerformance will not "
383 "be optimal.\n", port);
386 printf("\nCore %u doing packet TX.\n", rte_lcore_id());
387 while (!quit_signal) {
389 for (port = 0; port < nb_ports; port++) {
390 /* skip ports that are not enabled */
391 if ((enabled_port_mask & (1 << port)) == 0)
394 struct rte_mbuf *bufs[BURST_SIZE_TX];
395 const uint16_t nb_rx = rte_ring_dequeue_burst(in_r,
396 (void *)bufs, BURST_SIZE_TX, NULL);
397 app_stats.tx.dequeue_pkts += nb_rx;
399 /* if we get no traffic, flush anything we have */
400 if (unlikely(nb_rx == 0)) {
401 flush_all_ports(tx_buffers, nb_ports);
405 /* for traffic we receive, queue it up for transmit */
407 rte_prefetch_non_temporal((void *)bufs[0]);
408 rte_prefetch_non_temporal((void *)bufs[1]);
409 rte_prefetch_non_temporal((void *)bufs[2]);
410 for (i = 0; i < nb_rx; i++) {
411 struct output_buffer *outbuf;
413 rte_prefetch_non_temporal((void *)bufs[i + 3]);
415 * workers should update in_port to hold the
418 outp = bufs[i]->port;
419 /* skip ports that are not enabled */
420 if ((enabled_port_mask & (1 << outp)) == 0)
423 outbuf = &tx_buffers[outp];
424 outbuf->mbufs[outbuf->count++] = bufs[i];
425 if (outbuf->count == BURST_SIZE_TX)
426 flush_one_port(outbuf, outp);
430 printf("\nCore %u exiting tx task.\n", rte_lcore_id());
435 int_handler(int sig_num)
437 printf("Exiting on signal %d\n", sig_num);
438 /* set quit flag for rx thread to exit */
439 quit_signal_dist = 1;
445 struct rte_eth_stats eth_stats;
447 const unsigned int num_workers = rte_lcore_count() - 4;
449 for (i = 0; i < rte_eth_dev_count(); i++) {
450 rte_eth_stats_get(i, ð_stats);
451 app_stats.port_rx_pkts[i] = eth_stats.ipackets;
452 app_stats.port_tx_pkts[i] = eth_stats.opackets;
455 printf("\n\nRX Thread:\n");
456 for (i = 0; i < rte_eth_dev_count(); i++) {
457 printf("Port %u Pktsin : %5.2f\n", i,
458 (app_stats.port_rx_pkts[i] -
459 prev_app_stats.port_rx_pkts[i])/1000000.0);
460 prev_app_stats.port_rx_pkts[i] = app_stats.port_rx_pkts[i];
462 printf(" - Received: %5.2f\n",
463 (app_stats.rx.rx_pkts -
464 prev_app_stats.rx.rx_pkts)/1000000.0);
465 printf(" - Returned: %5.2f\n",
466 (app_stats.rx.returned_pkts -
467 prev_app_stats.rx.returned_pkts)/1000000.0);
468 printf(" - Enqueued: %5.2f\n",
469 (app_stats.rx.enqueued_pkts -
470 prev_app_stats.rx.enqueued_pkts)/1000000.0);
471 printf(" - Dropped: %s%5.2f%s\n", ANSI_COLOR_RED,
472 (app_stats.rx.enqdrop_pkts -
473 prev_app_stats.rx.enqdrop_pkts)/1000000.0,
476 printf("Distributor thread:\n");
477 printf(" - In: %5.2f\n",
478 (app_stats.dist.in_pkts -
479 prev_app_stats.dist.in_pkts)/1000000.0);
480 printf(" - Returned: %5.2f\n",
481 (app_stats.dist.ret_pkts -
482 prev_app_stats.dist.ret_pkts)/1000000.0);
483 printf(" - Sent: %5.2f\n",
484 (app_stats.dist.sent_pkts -
485 prev_app_stats.dist.sent_pkts)/1000000.0);
486 printf(" - Dropped %s%5.2f%s\n", ANSI_COLOR_RED,
487 (app_stats.dist.enqdrop_pkts -
488 prev_app_stats.dist.enqdrop_pkts)/1000000.0,
491 printf("TX thread:\n");
492 printf(" - Dequeued: %5.2f\n",
493 (app_stats.tx.dequeue_pkts -
494 prev_app_stats.tx.dequeue_pkts)/1000000.0);
495 for (i = 0; i < rte_eth_dev_count(); i++) {
496 printf("Port %u Pktsout: %5.2f\n",
497 i, (app_stats.port_tx_pkts[i] -
498 prev_app_stats.port_tx_pkts[i])/1000000.0);
499 prev_app_stats.port_tx_pkts[i] = app_stats.port_tx_pkts[i];
501 printf(" - Transmitted: %5.2f\n",
502 (app_stats.tx.tx_pkts -
503 prev_app_stats.tx.tx_pkts)/1000000.0);
504 printf(" - Dropped: %s%5.2f%s\n", ANSI_COLOR_RED,
505 (app_stats.tx.enqdrop_pkts -
506 prev_app_stats.tx.enqdrop_pkts)/1000000.0,
509 prev_app_stats.rx.rx_pkts = app_stats.rx.rx_pkts;
510 prev_app_stats.rx.returned_pkts = app_stats.rx.returned_pkts;
511 prev_app_stats.rx.enqueued_pkts = app_stats.rx.enqueued_pkts;
512 prev_app_stats.rx.enqdrop_pkts = app_stats.rx.enqdrop_pkts;
513 prev_app_stats.dist.in_pkts = app_stats.dist.in_pkts;
514 prev_app_stats.dist.ret_pkts = app_stats.dist.ret_pkts;
515 prev_app_stats.dist.sent_pkts = app_stats.dist.sent_pkts;
516 prev_app_stats.dist.enqdrop_pkts = app_stats.dist.enqdrop_pkts;
517 prev_app_stats.tx.dequeue_pkts = app_stats.tx.dequeue_pkts;
518 prev_app_stats.tx.tx_pkts = app_stats.tx.tx_pkts;
519 prev_app_stats.tx.enqdrop_pkts = app_stats.tx.enqdrop_pkts;
521 for (i = 0; i < num_workers; i++) {
522 printf("Worker %02u Pkts: %5.2f. Bursts(1-8): ", i,
523 (app_stats.worker_pkts[i] -
524 prev_app_stats.worker_pkts[i])/1000000.0);
525 for (j = 0; j < 8; j++) {
526 printf("%"PRIu64" ", app_stats.worker_bursts[i][j]);
527 app_stats.worker_bursts[i][j] = 0;
530 prev_app_stats.worker_pkts[i] = app_stats.worker_pkts[i];
535 lcore_worker(struct lcore_params *p)
537 struct rte_distributor *d = p->d;
538 const unsigned id = p->worker_id;
539 unsigned int num = 0;
543 * for single port, xor_val will be zero so we won't modify the output
544 * port, otherwise we send traffic from 0 to 1, 2 to 3, and vice versa
546 const unsigned xor_val = (rte_eth_dev_count() > 1);
547 struct rte_mbuf *buf[8] __rte_cache_aligned;
549 for (i = 0; i < 8; i++)
552 app_stats.worker_pkts[p->worker_id] = 1;
554 printf("\nCore %u acting as worker core.\n", rte_lcore_id());
555 while (!quit_signal_work) {
556 num = rte_distributor_get_pkt(d, id, buf, buf, num);
557 /* Do a little bit of work for each packet */
558 for (i = 0; i < num; i++) {
559 uint64_t t = rte_rdtsc()+100;
561 while (rte_rdtsc() < t)
563 buf[i]->port ^= xor_val;
566 app_stats.worker_pkts[p->worker_id] += num;
568 app_stats.worker_bursts[p->worker_id][num-1]++;
575 print_usage(const char *prgname)
577 printf("%s [EAL options] -- -p PORTMASK\n"
578 " -p PORTMASK: hexadecimal bitmask of ports to configure\n",
583 parse_portmask(const char *portmask)
588 /* parse hexadecimal string */
589 pm = strtoul(portmask, &end, 16);
590 if ((portmask[0] == '\0') || (end == NULL) || (*end != '\0'))
599 /* Parse the argument given in the command line of the application */
601 parse_args(int argc, char **argv)
606 char *prgname = argv[0];
607 static struct option lgopts[] = {
613 while ((opt = getopt_long(argc, argvopt, "p:",
614 lgopts, &option_index)) != EOF) {
619 enabled_port_mask = parse_portmask(optarg);
620 if (enabled_port_mask == 0) {
621 printf("invalid portmask\n");
622 print_usage(prgname);
628 print_usage(prgname);
634 print_usage(prgname);
638 argv[optind-1] = prgname;
640 optind = 1; /* reset getopt lib */
644 /* Main function, does initialization and calls the per-lcore functions */
646 main(int argc, char *argv[])
648 struct rte_mempool *mbuf_pool;
649 struct rte_distributor *d;
650 struct rte_ring *dist_tx_ring;
651 struct rte_ring *rx_dist_ring;
652 unsigned lcore_id, worker_id = 0;
655 uint16_t nb_ports_available;
658 /* catch ctrl-c so we can print on exit */
659 signal(SIGINT, int_handler);
662 int ret = rte_eal_init(argc, argv);
664 rte_exit(EXIT_FAILURE, "Error with EAL initialization\n");
668 /* parse application arguments (after the EAL ones) */
669 ret = parse_args(argc, argv);
671 rte_exit(EXIT_FAILURE, "Invalid distributor parameters\n");
673 if (rte_lcore_count() < 5)
674 rte_exit(EXIT_FAILURE, "Error, This application needs at "
675 "least 5 logical cores to run:\n"
676 "1 lcore for stats (can be core 0)\n"
677 "1 lcore for packet RX\n"
678 "1 lcore for distribution\n"
679 "1 lcore for packet TX\n"
680 "and at least 1 lcore for worker threads\n");
682 nb_ports = rte_eth_dev_count();
684 rte_exit(EXIT_FAILURE, "Error: no ethernet ports detected\n");
685 if (nb_ports != 1 && (nb_ports & 1))
686 rte_exit(EXIT_FAILURE, "Error: number of ports must be even, except "
687 "when using a single port\n");
689 mbuf_pool = rte_pktmbuf_pool_create("MBUF_POOL",
690 NUM_MBUFS * nb_ports, MBUF_CACHE_SIZE, 0,
691 RTE_MBUF_DEFAULT_BUF_SIZE, rte_socket_id());
692 if (mbuf_pool == NULL)
693 rte_exit(EXIT_FAILURE, "Cannot create mbuf pool\n");
694 nb_ports_available = nb_ports;
696 /* initialize all ports */
697 for (portid = 0; portid < nb_ports; portid++) {
698 /* skip ports that are not enabled */
699 if ((enabled_port_mask & (1 << portid)) == 0) {
700 printf("\nSkipping disabled port %d\n", portid);
701 nb_ports_available--;
705 printf("Initializing port %u... done\n", portid);
707 if (port_init(portid, mbuf_pool) != 0)
708 rte_exit(EXIT_FAILURE, "Cannot initialize port %u\n",
712 if (!nb_ports_available) {
713 rte_exit(EXIT_FAILURE,
714 "All available ports are disabled. Please set portmask.\n");
717 d = rte_distributor_create("PKT_DIST", rte_socket_id(),
718 rte_lcore_count() - 4,
721 rte_exit(EXIT_FAILURE, "Cannot create distributor\n");
724 * scheduler ring is read by the transmitter core, and written to
727 dist_tx_ring = rte_ring_create("Output_ring", SCHED_TX_RING_SZ,
728 rte_socket_id(), RING_F_SC_DEQ | RING_F_SP_ENQ);
729 if (dist_tx_ring == NULL)
730 rte_exit(EXIT_FAILURE, "Cannot create output ring\n");
732 rx_dist_ring = rte_ring_create("Input_ring", SCHED_RX_RING_SZ,
733 rte_socket_id(), RING_F_SC_DEQ | RING_F_SP_ENQ);
734 if (rx_dist_ring == NULL)
735 rte_exit(EXIT_FAILURE, "Cannot create output ring\n");
737 RTE_LCORE_FOREACH_SLAVE(lcore_id) {
738 if (worker_id == rte_lcore_count() - 3) {
739 printf("Starting distributor on lcore_id %d\n",
741 /* distributor core */
742 struct lcore_params *p =
743 rte_malloc(NULL, sizeof(*p), 0);
745 rte_panic("malloc failure\n");
746 *p = (struct lcore_params){worker_id, d,
747 rx_dist_ring, dist_tx_ring, mbuf_pool};
748 rte_eal_remote_launch(
749 (lcore_function_t *)lcore_distributor,
751 } else if (worker_id == rte_lcore_count() - 4) {
752 printf("Starting tx on worker_id %d, lcore_id %d\n",
753 worker_id, lcore_id);
755 rte_eal_remote_launch((lcore_function_t *)lcore_tx,
756 dist_tx_ring, lcore_id);
757 } else if (worker_id == rte_lcore_count() - 2) {
758 printf("Starting rx on worker_id %d, lcore_id %d\n",
759 worker_id, lcore_id);
761 struct lcore_params *p =
762 rte_malloc(NULL, sizeof(*p), 0);
764 rte_panic("malloc failure\n");
765 *p = (struct lcore_params){worker_id, d, rx_dist_ring,
766 dist_tx_ring, mbuf_pool};
767 rte_eal_remote_launch((lcore_function_t *)lcore_rx,
770 printf("Starting worker on worker_id %d, lcore_id %d\n",
771 worker_id, lcore_id);
772 struct lcore_params *p =
773 rte_malloc(NULL, sizeof(*p), 0);
775 rte_panic("malloc failure\n");
776 *p = (struct lcore_params){worker_id, d, rx_dist_ring,
777 dist_tx_ring, mbuf_pool};
779 rte_eal_remote_launch((lcore_function_t *)lcore_worker,
785 freq = rte_get_timer_hz();
786 t = rte_rdtsc() + freq;
787 while (!quit_signal_dist) {
788 if (t < rte_rdtsc()) {
790 t = rte_rdtsc() + freq;
795 RTE_LCORE_FOREACH_SLAVE(lcore_id) {
796 if (rte_eal_wait_lcore(lcore_id) < 0)