4 * Copyright(c) 2010-2017 Intel Corporation. All rights reserved.
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
10 * * Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * * Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in
14 * the documentation and/or other materials provided with the
16 * * Neither the name of Intel Corporation nor the names of its
17 * contributors may be used to endorse or promote products derived
18 * from this software without specific prior written permission.
20 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
21 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
22 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
23 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
24 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
25 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
26 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
27 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
28 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
29 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
30 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
40 #include <rte_ethdev.h>
41 #include <rte_cycles.h>
42 #include <rte_malloc.h>
43 #include <rte_debug.h>
44 #include <rte_prefetch.h>
45 #include <rte_distributor.h>
46 #include <rte_pause.h>
48 #define RX_RING_SIZE 512
49 #define TX_RING_SIZE 512
50 #define NUM_MBUFS ((64*1024)-1)
51 #define MBUF_CACHE_SIZE 128
53 #define SCHED_RX_RING_SZ 8192
54 #define SCHED_TX_RING_SZ 65536
55 #define BURST_SIZE_TX 32
57 #define RTE_LOGTYPE_DISTRAPP RTE_LOGTYPE_USER1
59 #define ANSI_COLOR_RED "\x1b[31m"
60 #define ANSI_COLOR_RESET "\x1b[0m"
62 /* mask of enabled ports */
63 static uint32_t enabled_port_mask;
64 volatile uint8_t quit_signal;
65 volatile uint8_t quit_signal_rx;
66 volatile uint8_t quit_signal_dist;
67 volatile uint8_t quit_signal_work;
69 static volatile struct app_stats {
72 uint64_t returned_pkts;
73 uint64_t enqueued_pkts;
74 uint64_t enqdrop_pkts;
75 } rx __rte_cache_aligned;
76 int pad1 __rte_cache_aligned;
82 uint64_t enqdrop_pkts;
83 } dist __rte_cache_aligned;
84 int pad2 __rte_cache_aligned;
87 uint64_t dequeue_pkts;
89 uint64_t enqdrop_pkts;
90 } tx __rte_cache_aligned;
91 int pad3 __rte_cache_aligned;
93 uint64_t worker_pkts[64] __rte_cache_aligned;
95 int pad4 __rte_cache_aligned;
97 uint64_t worker_bursts[64][8] __rte_cache_aligned;
99 int pad5 __rte_cache_aligned;
101 uint64_t port_rx_pkts[64] __rte_cache_aligned;
102 uint64_t port_tx_pkts[64] __rte_cache_aligned;
105 struct app_stats prev_app_stats;
107 static const struct rte_eth_conf port_conf_default = {
109 .mq_mode = ETH_MQ_RX_RSS,
110 .max_rx_pkt_len = ETHER_MAX_LEN,
113 .mq_mode = ETH_MQ_TX_NONE,
117 .rss_hf = ETH_RSS_IP | ETH_RSS_UDP |
118 ETH_RSS_TCP | ETH_RSS_SCTP,
123 struct output_buffer {
125 struct rte_mbuf *mbufs[BURST_SIZE];
128 static void print_stats(void);
131 * Initialises a given port using global settings and with the rx buffers
132 * coming from the mbuf_pool passed as parameter
135 port_init(uint8_t port, struct rte_mempool *mbuf_pool)
137 struct rte_eth_conf port_conf = port_conf_default;
138 const uint16_t rxRings = 1, txRings = rte_lcore_count() - 1;
141 uint16_t nb_rxd = RX_RING_SIZE;
142 uint16_t nb_txd = TX_RING_SIZE;
144 if (port >= rte_eth_dev_count())
147 retval = rte_eth_dev_configure(port, rxRings, txRings, &port_conf);
151 retval = rte_eth_dev_adjust_nb_rx_tx_desc(port, &nb_rxd, &nb_txd);
155 for (q = 0; q < rxRings; q++) {
156 retval = rte_eth_rx_queue_setup(port, q, nb_rxd,
157 rte_eth_dev_socket_id(port),
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;
176 rte_eth_link_get_nowait(port, &link);
177 while (!link.link_status) {
178 printf("Waiting for Link up on port %"PRIu8"\n", port);
180 rte_eth_link_get_nowait(port, &link);
183 if (!link.link_status) {
184 printf("Link down on port %"PRIu8"\n", port);
188 struct ether_addr addr;
189 rte_eth_macaddr_get(port, &addr);
190 printf("Port %u MAC: %02"PRIx8" %02"PRIx8" %02"PRIx8
191 " %02"PRIx8" %02"PRIx8" %02"PRIx8"\n",
193 addr.addr_bytes[0], addr.addr_bytes[1],
194 addr.addr_bytes[2], addr.addr_bytes[3],
195 addr.addr_bytes[4], addr.addr_bytes[5]);
197 rte_eth_promiscuous_enable(port);
202 struct lcore_params {
204 struct rte_distributor *d;
205 struct rte_ring *rx_dist_ring;
206 struct rte_ring *dist_tx_ring;
207 struct rte_mempool *mem_pool;
211 lcore_rx(struct lcore_params *p)
213 const uint8_t nb_ports = rte_eth_dev_count();
214 const int socket_id = rte_socket_id();
216 struct rte_mbuf *bufs[BURST_SIZE*2];
218 for (port = 0; port < nb_ports; port++) {
219 /* skip ports that are not enabled */
220 if ((enabled_port_mask & (1 << port)) == 0)
223 if (rte_eth_dev_socket_id(port) > 0 &&
224 rte_eth_dev_socket_id(port) != socket_id)
225 printf("WARNING, port %u is on remote NUMA node to "
226 "RX thread.\n\tPerformance will not "
227 "be optimal.\n", port);
230 printf("\nCore %u doing packet RX.\n", rte_lcore_id());
232 while (!quit_signal_rx) {
234 /* skip ports that are not enabled */
235 if ((enabled_port_mask & (1 << port)) == 0) {
236 if (++port == nb_ports)
240 const uint16_t nb_rx = rte_eth_rx_burst(port, 0, bufs,
242 if (unlikely(nb_rx == 0)) {
243 if (++port == nb_ports)
247 app_stats.rx.rx_pkts += nb_rx;
250 * You can run the distributor on the rx core with this code. Returned
251 * packets are then send straight to the tx core.
254 rte_distributor_process(d, bufs, nb_rx);
255 const uint16_t nb_ret = rte_distributor_returned_pktsd,
258 app_stats.rx.returned_pkts += nb_ret;
259 if (unlikely(nb_ret == 0)) {
260 if (++port == nb_ports)
265 struct rte_ring *tx_ring = p->dist_tx_ring;
266 uint16_t sent = rte_ring_enqueue_burst(tx_ring,
267 (void *)bufs, nb_ret, NULL);
269 uint16_t nb_ret = nb_rx;
271 * Swap the following two lines if you want the rx traffic
272 * to go directly to tx, no distribution.
274 struct rte_ring *out_ring = p->rx_dist_ring;
275 /* struct rte_ring *out_ring = p->dist_tx_ring; */
277 uint16_t sent = rte_ring_enqueue_burst(out_ring,
278 (void *)bufs, nb_ret, NULL);
281 app_stats.rx.enqueued_pkts += sent;
282 if (unlikely(sent < nb_ret)) {
283 app_stats.rx.enqdrop_pkts += nb_ret - sent;
284 RTE_LOG_DP(DEBUG, DISTRAPP,
285 "%s:Packet loss due to full ring\n", __func__);
286 while (sent < nb_ret)
287 rte_pktmbuf_free(bufs[sent++]);
289 if (++port == nb_ports)
292 /* set worker & tx threads quit flag */
293 printf("\nCore %u exiting rx task.\n", rte_lcore_id());
299 flush_one_port(struct output_buffer *outbuf, uint8_t outp)
301 unsigned int nb_tx = rte_eth_tx_burst(outp, 0,
302 outbuf->mbufs, outbuf->count);
303 app_stats.tx.tx_pkts += outbuf->count;
305 if (unlikely(nb_tx < outbuf->count)) {
306 app_stats.tx.enqdrop_pkts += outbuf->count - nb_tx;
308 rte_pktmbuf_free(outbuf->mbufs[nb_tx]);
309 } while (++nb_tx < outbuf->count);
315 flush_all_ports(struct output_buffer *tx_buffers, uint8_t nb_ports)
319 for (outp = 0; outp < nb_ports; outp++) {
320 /* skip ports that are not enabled */
321 if ((enabled_port_mask & (1 << outp)) == 0)
324 if (tx_buffers[outp].count == 0)
327 flush_one_port(&tx_buffers[outp], outp);
334 lcore_distributor(struct lcore_params *p)
336 struct rte_ring *in_r = p->rx_dist_ring;
337 struct rte_ring *out_r = p->dist_tx_ring;
338 struct rte_mbuf *bufs[BURST_SIZE * 4];
339 struct rte_distributor *d = p->d;
341 printf("\nCore %u acting as distributor core.\n", rte_lcore_id());
342 while (!quit_signal_dist) {
343 const uint16_t nb_rx = rte_ring_dequeue_burst(in_r,
344 (void *)bufs, BURST_SIZE*1, NULL);
346 app_stats.dist.in_pkts += nb_rx;
348 /* Distribute the packets */
349 rte_distributor_process(d, bufs, nb_rx);
351 const uint16_t nb_ret =
352 rte_distributor_returned_pkts(d,
355 if (unlikely(nb_ret == 0))
357 app_stats.dist.ret_pkts += nb_ret;
359 uint16_t sent = rte_ring_enqueue_burst(out_r,
360 (void *)bufs, nb_ret, NULL);
361 app_stats.dist.sent_pkts += sent;
362 if (unlikely(sent < nb_ret)) {
363 app_stats.dist.enqdrop_pkts += nb_ret - sent;
364 RTE_LOG(DEBUG, DISTRAPP,
365 "%s:Packet loss due to full out ring\n",
367 while (sent < nb_ret)
368 rte_pktmbuf_free(bufs[sent++]);
372 printf("\nCore %u exiting distributor task.\n", rte_lcore_id());
373 quit_signal_work = 1;
375 rte_distributor_flush(d);
376 /* Unblock any returns so workers can exit */
377 rte_distributor_clear_returns(d);
384 lcore_tx(struct rte_ring *in_r)
386 static struct output_buffer tx_buffers[RTE_MAX_ETHPORTS];
387 const uint8_t nb_ports = rte_eth_dev_count();
388 const int socket_id = rte_socket_id();
391 for (port = 0; port < nb_ports; port++) {
392 /* skip ports that are not enabled */
393 if ((enabled_port_mask & (1 << port)) == 0)
396 if (rte_eth_dev_socket_id(port) > 0 &&
397 rte_eth_dev_socket_id(port) != socket_id)
398 printf("WARNING, port %u is on remote NUMA node to "
399 "TX thread.\n\tPerformance will not "
400 "be optimal.\n", port);
403 printf("\nCore %u doing packet TX.\n", rte_lcore_id());
404 while (!quit_signal) {
406 for (port = 0; port < nb_ports; port++) {
407 /* skip ports that are not enabled */
408 if ((enabled_port_mask & (1 << port)) == 0)
411 struct rte_mbuf *bufs[BURST_SIZE_TX];
412 const uint16_t nb_rx = rte_ring_dequeue_burst(in_r,
413 (void *)bufs, BURST_SIZE_TX, NULL);
414 app_stats.tx.dequeue_pkts += nb_rx;
416 /* if we get no traffic, flush anything we have */
417 if (unlikely(nb_rx == 0)) {
418 flush_all_ports(tx_buffers, nb_ports);
422 /* for traffic we receive, queue it up for transmit */
424 rte_prefetch_non_temporal((void *)bufs[0]);
425 rte_prefetch_non_temporal((void *)bufs[1]);
426 rte_prefetch_non_temporal((void *)bufs[2]);
427 for (i = 0; i < nb_rx; i++) {
428 struct output_buffer *outbuf;
430 rte_prefetch_non_temporal((void *)bufs[i + 3]);
432 * workers should update in_port to hold the
435 outp = bufs[i]->port;
436 /* skip ports that are not enabled */
437 if ((enabled_port_mask & (1 << outp)) == 0)
440 outbuf = &tx_buffers[outp];
441 outbuf->mbufs[outbuf->count++] = bufs[i];
442 if (outbuf->count == BURST_SIZE_TX)
443 flush_one_port(outbuf, outp);
447 printf("\nCore %u exiting tx task.\n", rte_lcore_id());
452 int_handler(int sig_num)
454 printf("Exiting on signal %d\n", sig_num);
455 /* set quit flag for rx thread to exit */
456 quit_signal_dist = 1;
462 struct rte_eth_stats eth_stats;
464 const unsigned int num_workers = rte_lcore_count() - 4;
466 for (i = 0; i < rte_eth_dev_count(); i++) {
467 rte_eth_stats_get(i, ð_stats);
468 app_stats.port_rx_pkts[i] = eth_stats.ipackets;
469 app_stats.port_tx_pkts[i] = eth_stats.opackets;
472 printf("\n\nRX Thread:\n");
473 for (i = 0; i < rte_eth_dev_count(); i++) {
474 printf("Port %u Pktsin : %5.2f\n", i,
475 (app_stats.port_rx_pkts[i] -
476 prev_app_stats.port_rx_pkts[i])/1000000.0);
477 prev_app_stats.port_rx_pkts[i] = app_stats.port_rx_pkts[i];
479 printf(" - Received: %5.2f\n",
480 (app_stats.rx.rx_pkts -
481 prev_app_stats.rx.rx_pkts)/1000000.0);
482 printf(" - Returned: %5.2f\n",
483 (app_stats.rx.returned_pkts -
484 prev_app_stats.rx.returned_pkts)/1000000.0);
485 printf(" - Enqueued: %5.2f\n",
486 (app_stats.rx.enqueued_pkts -
487 prev_app_stats.rx.enqueued_pkts)/1000000.0);
488 printf(" - Dropped: %s%5.2f%s\n", ANSI_COLOR_RED,
489 (app_stats.rx.enqdrop_pkts -
490 prev_app_stats.rx.enqdrop_pkts)/1000000.0,
493 printf("Distributor thread:\n");
494 printf(" - In: %5.2f\n",
495 (app_stats.dist.in_pkts -
496 prev_app_stats.dist.in_pkts)/1000000.0);
497 printf(" - Returned: %5.2f\n",
498 (app_stats.dist.ret_pkts -
499 prev_app_stats.dist.ret_pkts)/1000000.0);
500 printf(" - Sent: %5.2f\n",
501 (app_stats.dist.sent_pkts -
502 prev_app_stats.dist.sent_pkts)/1000000.0);
503 printf(" - Dropped %s%5.2f%s\n", ANSI_COLOR_RED,
504 (app_stats.dist.enqdrop_pkts -
505 prev_app_stats.dist.enqdrop_pkts)/1000000.0,
508 printf("TX thread:\n");
509 printf(" - Dequeued: %5.2f\n",
510 (app_stats.tx.dequeue_pkts -
511 prev_app_stats.tx.dequeue_pkts)/1000000.0);
512 for (i = 0; i < rte_eth_dev_count(); i++) {
513 printf("Port %u Pktsout: %5.2f\n",
514 i, (app_stats.port_tx_pkts[i] -
515 prev_app_stats.port_tx_pkts[i])/1000000.0);
516 prev_app_stats.port_tx_pkts[i] = app_stats.port_tx_pkts[i];
518 printf(" - Transmitted: %5.2f\n",
519 (app_stats.tx.tx_pkts -
520 prev_app_stats.tx.tx_pkts)/1000000.0);
521 printf(" - Dropped: %s%5.2f%s\n", ANSI_COLOR_RED,
522 (app_stats.tx.enqdrop_pkts -
523 prev_app_stats.tx.enqdrop_pkts)/1000000.0,
526 prev_app_stats.rx.rx_pkts = app_stats.rx.rx_pkts;
527 prev_app_stats.rx.returned_pkts = app_stats.rx.returned_pkts;
528 prev_app_stats.rx.enqueued_pkts = app_stats.rx.enqueued_pkts;
529 prev_app_stats.rx.enqdrop_pkts = app_stats.rx.enqdrop_pkts;
530 prev_app_stats.dist.in_pkts = app_stats.dist.in_pkts;
531 prev_app_stats.dist.ret_pkts = app_stats.dist.ret_pkts;
532 prev_app_stats.dist.sent_pkts = app_stats.dist.sent_pkts;
533 prev_app_stats.dist.enqdrop_pkts = app_stats.dist.enqdrop_pkts;
534 prev_app_stats.tx.dequeue_pkts = app_stats.tx.dequeue_pkts;
535 prev_app_stats.tx.tx_pkts = app_stats.tx.tx_pkts;
536 prev_app_stats.tx.enqdrop_pkts = app_stats.tx.enqdrop_pkts;
538 for (i = 0; i < num_workers; i++) {
539 printf("Worker %02u Pkts: %5.2f. Bursts(1-8): ", i,
540 (app_stats.worker_pkts[i] -
541 prev_app_stats.worker_pkts[i])/1000000.0);
542 for (j = 0; j < 8; j++) {
543 printf("%"PRIu64" ", app_stats.worker_bursts[i][j]);
544 app_stats.worker_bursts[i][j] = 0;
547 prev_app_stats.worker_pkts[i] = app_stats.worker_pkts[i];
552 lcore_worker(struct lcore_params *p)
554 struct rte_distributor *d = p->d;
555 const unsigned id = p->worker_id;
556 unsigned int num = 0;
560 * for single port, xor_val will be zero so we won't modify the output
561 * port, otherwise we send traffic from 0 to 1, 2 to 3, and vice versa
563 const unsigned xor_val = (rte_eth_dev_count() > 1);
564 struct rte_mbuf *buf[8] __rte_cache_aligned;
566 for (i = 0; i < 8; i++)
569 app_stats.worker_pkts[p->worker_id] = 1;
571 printf("\nCore %u acting as worker core.\n", rte_lcore_id());
572 while (!quit_signal_work) {
573 num = rte_distributor_get_pkt(d, id, buf, buf, num);
574 /* Do a little bit of work for each packet */
575 for (i = 0; i < num; i++) {
576 uint64_t t = rte_rdtsc()+100;
578 while (rte_rdtsc() < t)
580 buf[i]->port ^= xor_val;
583 app_stats.worker_pkts[p->worker_id] += num;
585 app_stats.worker_bursts[p->worker_id][num-1]++;
592 print_usage(const char *prgname)
594 printf("%s [EAL options] -- -p PORTMASK\n"
595 " -p PORTMASK: hexadecimal bitmask of ports to configure\n",
600 parse_portmask(const char *portmask)
605 /* parse hexadecimal string */
606 pm = strtoul(portmask, &end, 16);
607 if ((portmask[0] == '\0') || (end == NULL) || (*end != '\0'))
616 /* Parse the argument given in the command line of the application */
618 parse_args(int argc, char **argv)
623 char *prgname = argv[0];
624 static struct option lgopts[] = {
630 while ((opt = getopt_long(argc, argvopt, "p:",
631 lgopts, &option_index)) != EOF) {
636 enabled_port_mask = parse_portmask(optarg);
637 if (enabled_port_mask == 0) {
638 printf("invalid portmask\n");
639 print_usage(prgname);
645 print_usage(prgname);
651 print_usage(prgname);
655 argv[optind-1] = prgname;
657 optind = 1; /* reset getopt lib */
661 /* Main function, does initialization and calls the per-lcore functions */
663 main(int argc, char *argv[])
665 struct rte_mempool *mbuf_pool;
666 struct rte_distributor *d;
667 struct rte_ring *dist_tx_ring;
668 struct rte_ring *rx_dist_ring;
669 unsigned lcore_id, worker_id = 0;
672 uint8_t nb_ports_available;
675 /* catch ctrl-c so we can print on exit */
676 signal(SIGINT, int_handler);
679 int ret = rte_eal_init(argc, argv);
681 rte_exit(EXIT_FAILURE, "Error with EAL initialization\n");
685 /* parse application arguments (after the EAL ones) */
686 ret = parse_args(argc, argv);
688 rte_exit(EXIT_FAILURE, "Invalid distributor parameters\n");
690 if (rte_lcore_count() < 5)
691 rte_exit(EXIT_FAILURE, "Error, This application needs at "
692 "least 5 logical cores to run:\n"
693 "1 lcore for stats (can be core 0)\n"
694 "1 lcore for packet RX\n"
695 "1 lcore for distribution\n"
696 "1 lcore for packet TX\n"
697 "and at least 1 lcore for worker threads\n");
699 nb_ports = rte_eth_dev_count();
701 rte_exit(EXIT_FAILURE, "Error: no ethernet ports detected\n");
702 if (nb_ports != 1 && (nb_ports & 1))
703 rte_exit(EXIT_FAILURE, "Error: number of ports must be even, except "
704 "when using a single port\n");
706 mbuf_pool = rte_pktmbuf_pool_create("MBUF_POOL",
707 NUM_MBUFS * nb_ports, MBUF_CACHE_SIZE, 0,
708 RTE_MBUF_DEFAULT_BUF_SIZE, rte_socket_id());
709 if (mbuf_pool == NULL)
710 rte_exit(EXIT_FAILURE, "Cannot create mbuf pool\n");
711 nb_ports_available = nb_ports;
713 /* initialize all ports */
714 for (portid = 0; portid < nb_ports; portid++) {
715 /* skip ports that are not enabled */
716 if ((enabled_port_mask & (1 << portid)) == 0) {
717 printf("\nSkipping disabled port %d\n", portid);
718 nb_ports_available--;
722 printf("Initializing port %u... done\n", (unsigned) portid);
724 if (port_init(portid, mbuf_pool) != 0)
725 rte_exit(EXIT_FAILURE, "Cannot initialize port %"PRIu8"\n",
729 if (!nb_ports_available) {
730 rte_exit(EXIT_FAILURE,
731 "All available ports are disabled. Please set portmask.\n");
734 d = rte_distributor_create("PKT_DIST", rte_socket_id(),
735 rte_lcore_count() - 4,
738 rte_exit(EXIT_FAILURE, "Cannot create distributor\n");
741 * scheduler ring is read by the transmitter core, and written to
744 dist_tx_ring = rte_ring_create("Output_ring", SCHED_TX_RING_SZ,
745 rte_socket_id(), RING_F_SC_DEQ | RING_F_SP_ENQ);
746 if (dist_tx_ring == NULL)
747 rte_exit(EXIT_FAILURE, "Cannot create output ring\n");
749 rx_dist_ring = rte_ring_create("Input_ring", SCHED_RX_RING_SZ,
750 rte_socket_id(), RING_F_SC_DEQ | RING_F_SP_ENQ);
751 if (rx_dist_ring == NULL)
752 rte_exit(EXIT_FAILURE, "Cannot create output ring\n");
754 RTE_LCORE_FOREACH_SLAVE(lcore_id) {
755 if (worker_id == rte_lcore_count() - 3) {
756 printf("Starting distributor on lcore_id %d\n",
758 /* distributor core */
759 struct lcore_params *p =
760 rte_malloc(NULL, sizeof(*p), 0);
762 rte_panic("malloc failure\n");
763 *p = (struct lcore_params){worker_id, d,
764 rx_dist_ring, dist_tx_ring, mbuf_pool};
765 rte_eal_remote_launch(
766 (lcore_function_t *)lcore_distributor,
768 } else if (worker_id == rte_lcore_count() - 4) {
769 printf("Starting tx on worker_id %d, lcore_id %d\n",
770 worker_id, lcore_id);
772 rte_eal_remote_launch((lcore_function_t *)lcore_tx,
773 dist_tx_ring, lcore_id);
774 } else if (worker_id == rte_lcore_count() - 2) {
775 printf("Starting rx on worker_id %d, lcore_id %d\n",
776 worker_id, lcore_id);
778 struct lcore_params *p =
779 rte_malloc(NULL, sizeof(*p), 0);
781 rte_panic("malloc failure\n");
782 *p = (struct lcore_params){worker_id, d, rx_dist_ring,
783 dist_tx_ring, mbuf_pool};
784 rte_eal_remote_launch((lcore_function_t *)lcore_rx,
787 printf("Starting worker on worker_id %d, lcore_id %d\n",
788 worker_id, lcore_id);
789 struct lcore_params *p =
790 rte_malloc(NULL, sizeof(*p), 0);
792 rte_panic("malloc failure\n");
793 *p = (struct lcore_params){worker_id, d, rx_dist_ring,
794 dist_tx_ring, mbuf_pool};
796 rte_eal_remote_launch((lcore_function_t *)lcore_worker,
802 freq = rte_get_timer_hz();
803 t = rte_rdtsc() + freq;
804 while (!quit_signal_dist) {
805 if (t < rte_rdtsc()) {
807 t = rte_rdtsc() + freq;
812 RTE_LCORE_FOREACH_SLAVE(lcore_id) {
813 if (rte_eal_wait_lcore(lcore_id) < 0)