net/sfc/base: remove obsolete check for pre-Siena hardware
[dpdk.git] / examples / distributor / main.c
1 /* SPDX-License-Identifier: BSD-3-Clause
2  * Copyright(c) 2010-2017 Intel Corporation
3  */
4
5 #include <stdint.h>
6 #include <inttypes.h>
7 #include <unistd.h>
8 #include <signal.h>
9 #include <getopt.h>
10
11 #include <rte_eal.h>
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
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
24 #define BURST_SIZE 64
25 #define SCHED_RX_RING_SZ 8192
26 #define SCHED_TX_RING_SZ 65536
27 #define BURST_SIZE_TX 32
28
29 #define RTE_LOGTYPE_DISTRAPP RTE_LOGTYPE_USER1
30
31 #define ANSI_COLOR_RED     "\x1b[31m"
32 #define ANSI_COLOR_RESET   "\x1b[0m"
33
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;
40
41 static volatile struct app_stats {
42         struct {
43                 uint64_t rx_pkts;
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;
49
50         struct {
51                 uint64_t in_pkts;
52                 uint64_t ret_pkts;
53                 uint64_t sent_pkts;
54                 uint64_t enqdrop_pkts;
55         } dist __rte_cache_aligned;
56         int pad2 __rte_cache_aligned;
57
58         struct {
59                 uint64_t dequeue_pkts;
60                 uint64_t tx_pkts;
61                 uint64_t enqdrop_pkts;
62         } tx __rte_cache_aligned;
63         int pad3 __rte_cache_aligned;
64
65         uint64_t worker_pkts[64] __rte_cache_aligned;
66
67         int pad4 __rte_cache_aligned;
68
69         uint64_t worker_bursts[64][8] __rte_cache_aligned;
70
71         int pad5 __rte_cache_aligned;
72
73         uint64_t port_rx_pkts[64] __rte_cache_aligned;
74         uint64_t port_tx_pkts[64] __rte_cache_aligned;
75 } app_stats;
76
77 struct app_stats prev_app_stats;
78
79 static const struct rte_eth_conf port_conf_default = {
80         .rxmode = {
81                 .mq_mode = ETH_MQ_RX_RSS,
82                 .max_rx_pkt_len = ETHER_MAX_LEN,
83         },
84         .txmode = {
85                 .mq_mode = ETH_MQ_TX_NONE,
86         },
87         .rx_adv_conf = {
88                 .rss_conf = {
89                         .rss_hf = ETH_RSS_IP | ETH_RSS_UDP |
90                                 ETH_RSS_TCP | ETH_RSS_SCTP,
91                 }
92         },
93 };
94
95 struct output_buffer {
96         unsigned count;
97         struct rte_mbuf *mbufs[BURST_SIZE];
98 };
99
100 static void print_stats(void);
101
102 /*
103  * Initialises a given port using global settings and with the rx buffers
104  * coming from the mbuf_pool passed as parameter
105  */
106 static inline int
107 port_init(uint16_t port, struct rte_mempool *mbuf_pool)
108 {
109         struct rte_eth_conf port_conf = port_conf_default;
110         const uint16_t rxRings = 1, txRings = rte_lcore_count() - 1;
111         int retval;
112         uint16_t q;
113         uint16_t nb_rxd = RX_RING_SIZE;
114         uint16_t nb_txd = TX_RING_SIZE;
115
116         if (port >= rte_eth_dev_count())
117                 return -1;
118
119         retval = rte_eth_dev_configure(port, rxRings, txRings, &port_conf);
120         if (retval != 0)
121                 return retval;
122
123         retval = rte_eth_dev_adjust_nb_rx_tx_desc(port, &nb_rxd, &nb_txd);
124         if (retval != 0)
125                 return retval;
126
127         for (q = 0; q < rxRings; q++) {
128                 retval = rte_eth_rx_queue_setup(port, q, nb_rxd,
129                                                 rte_eth_dev_socket_id(port),
130                                                 NULL, mbuf_pool);
131                 if (retval < 0)
132                         return retval;
133         }
134
135         for (q = 0; q < txRings; q++) {
136                 retval = rte_eth_tx_queue_setup(port, q, nb_txd,
137                                                 rte_eth_dev_socket_id(port),
138                                                 NULL);
139                 if (retval < 0)
140                         return retval;
141         }
142
143         retval = rte_eth_dev_start(port);
144         if (retval < 0)
145                 return retval;
146
147         struct rte_eth_link link;
148         rte_eth_link_get_nowait(port, &link);
149         while (!link.link_status) {
150                 printf("Waiting for Link up on port %"PRIu16"\n", port);
151                 sleep(1);
152                 rte_eth_link_get_nowait(port, &link);
153         }
154
155         if (!link.link_status) {
156                 printf("Link down on port %"PRIu16"\n", port);
157                 return 0;
158         }
159
160         struct ether_addr addr;
161         rte_eth_macaddr_get(port, &addr);
162         printf("Port %u MAC: %02"PRIx8" %02"PRIx8" %02"PRIx8
163                         " %02"PRIx8" %02"PRIx8" %02"PRIx8"\n",
164                         port,
165                         addr.addr_bytes[0], addr.addr_bytes[1],
166                         addr.addr_bytes[2], addr.addr_bytes[3],
167                         addr.addr_bytes[4], addr.addr_bytes[5]);
168
169         rte_eth_promiscuous_enable(port);
170
171         return 0;
172 }
173
174 struct lcore_params {
175         unsigned worker_id;
176         struct rte_distributor *d;
177         struct rte_ring *rx_dist_ring;
178         struct rte_ring *dist_tx_ring;
179         struct rte_mempool *mem_pool;
180 };
181
182 static int
183 lcore_rx(struct lcore_params *p)
184 {
185         const uint16_t nb_ports = rte_eth_dev_count();
186         const int socket_id = rte_socket_id();
187         uint16_t port;
188         struct rte_mbuf *bufs[BURST_SIZE*2];
189
190         for (port = 0; port < nb_ports; port++) {
191                 /* skip ports that are not enabled */
192                 if ((enabled_port_mask & (1 << port)) == 0)
193                         continue;
194
195                 if (rte_eth_dev_socket_id(port) > 0 &&
196                                 rte_eth_dev_socket_id(port) != socket_id)
197                         printf("WARNING, port %u is on remote NUMA node to "
198                                         "RX thread.\n\tPerformance will not "
199                                         "be optimal.\n", port);
200         }
201
202         printf("\nCore %u doing packet RX.\n", rte_lcore_id());
203         port = 0;
204         while (!quit_signal_rx) {
205
206                 /* skip ports that are not enabled */
207                 if ((enabled_port_mask & (1 << port)) == 0) {
208                         if (++port == nb_ports)
209                                 port = 0;
210                         continue;
211                 }
212                 const uint16_t nb_rx = rte_eth_rx_burst(port, 0, bufs,
213                                 BURST_SIZE);
214                 if (unlikely(nb_rx == 0)) {
215                         if (++port == nb_ports)
216                                 port = 0;
217                         continue;
218                 }
219                 app_stats.rx.rx_pkts += nb_rx;
220
221 /*
222  * You can run the distributor on the rx core with this code. Returned
223  * packets are then send straight to the tx core.
224  */
225 #if 0
226         rte_distributor_process(d, bufs, nb_rx);
227         const uint16_t nb_ret = rte_distributor_returned_pktsd,
228                         bufs, BURST_SIZE*2);
229
230                 app_stats.rx.returned_pkts += nb_ret;
231                 if (unlikely(nb_ret == 0)) {
232                         if (++port == nb_ports)
233                                 port = 0;
234                         continue;
235                 }
236
237                 struct rte_ring *tx_ring = p->dist_tx_ring;
238                 uint16_t sent = rte_ring_enqueue_burst(tx_ring,
239                                 (void *)bufs, nb_ret, NULL);
240 #else
241                 uint16_t nb_ret = nb_rx;
242                 /*
243                  * Swap the following two lines if you want the rx traffic
244                  * to go directly to tx, no distribution.
245                  */
246                 struct rte_ring *out_ring = p->rx_dist_ring;
247                 /* struct rte_ring *out_ring = p->dist_tx_ring; */
248
249                 uint16_t sent = rte_ring_enqueue_burst(out_ring,
250                                 (void *)bufs, nb_ret, NULL);
251 #endif
252
253                 app_stats.rx.enqueued_pkts += sent;
254                 if (unlikely(sent < nb_ret)) {
255                         app_stats.rx.enqdrop_pkts +=  nb_ret - sent;
256                         RTE_LOG_DP(DEBUG, DISTRAPP,
257                                 "%s:Packet loss due to full ring\n", __func__);
258                         while (sent < nb_ret)
259                                 rte_pktmbuf_free(bufs[sent++]);
260                 }
261                 if (++port == nb_ports)
262                         port = 0;
263         }
264         /* set worker & tx threads quit flag */
265         printf("\nCore %u exiting rx task.\n", rte_lcore_id());
266         quit_signal = 1;
267         return 0;
268 }
269
270 static inline void
271 flush_one_port(struct output_buffer *outbuf, uint8_t outp)
272 {
273         unsigned int nb_tx = rte_eth_tx_burst(outp, 0,
274                         outbuf->mbufs, outbuf->count);
275         app_stats.tx.tx_pkts += outbuf->count;
276
277         if (unlikely(nb_tx < outbuf->count)) {
278                 app_stats.tx.enqdrop_pkts +=  outbuf->count - nb_tx;
279                 do {
280                         rte_pktmbuf_free(outbuf->mbufs[nb_tx]);
281                 } while (++nb_tx < outbuf->count);
282         }
283         outbuf->count = 0;
284 }
285
286 static inline void
287 flush_all_ports(struct output_buffer *tx_buffers, uint16_t nb_ports)
288 {
289         uint16_t outp;
290
291         for (outp = 0; outp < nb_ports; outp++) {
292                 /* skip ports that are not enabled */
293                 if ((enabled_port_mask & (1 << outp)) == 0)
294                         continue;
295
296                 if (tx_buffers[outp].count == 0)
297                         continue;
298
299                 flush_one_port(&tx_buffers[outp], outp);
300         }
301 }
302
303
304
305 static int
306 lcore_distributor(struct lcore_params *p)
307 {
308         struct rte_ring *in_r = p->rx_dist_ring;
309         struct rte_ring *out_r = p->dist_tx_ring;
310         struct rte_mbuf *bufs[BURST_SIZE * 4];
311         struct rte_distributor *d = p->d;
312
313         printf("\nCore %u acting as distributor core.\n", rte_lcore_id());
314         while (!quit_signal_dist) {
315                 const uint16_t nb_rx = rte_ring_dequeue_burst(in_r,
316                                 (void *)bufs, BURST_SIZE*1, NULL);
317                 if (nb_rx) {
318                         app_stats.dist.in_pkts += nb_rx;
319
320                         /* Distribute the packets */
321                         rte_distributor_process(d, bufs, nb_rx);
322                         /* Handle Returns */
323                         const uint16_t nb_ret =
324                                 rte_distributor_returned_pkts(d,
325                                         bufs, BURST_SIZE*2);
326
327                         if (unlikely(nb_ret == 0))
328                                 continue;
329                         app_stats.dist.ret_pkts += nb_ret;
330
331                         uint16_t sent = rte_ring_enqueue_burst(out_r,
332                                         (void *)bufs, nb_ret, NULL);
333                         app_stats.dist.sent_pkts += sent;
334                         if (unlikely(sent < nb_ret)) {
335                                 app_stats.dist.enqdrop_pkts += nb_ret - sent;
336                                 RTE_LOG(DEBUG, DISTRAPP,
337                                         "%s:Packet loss due to full out ring\n",
338                                         __func__);
339                                 while (sent < nb_ret)
340                                         rte_pktmbuf_free(bufs[sent++]);
341                         }
342                 }
343         }
344         printf("\nCore %u exiting distributor task.\n", rte_lcore_id());
345         quit_signal_work = 1;
346
347         rte_distributor_flush(d);
348         /* Unblock any returns so workers can exit */
349         rte_distributor_clear_returns(d);
350         quit_signal_rx = 1;
351         return 0;
352 }
353
354
355 static int
356 lcore_tx(struct rte_ring *in_r)
357 {
358         static struct output_buffer tx_buffers[RTE_MAX_ETHPORTS];
359         const uint16_t nb_ports = rte_eth_dev_count();
360         const int socket_id = rte_socket_id();
361         uint16_t port;
362
363         for (port = 0; port < nb_ports; port++) {
364                 /* skip ports that are not enabled */
365                 if ((enabled_port_mask & (1 << port)) == 0)
366                         continue;
367
368                 if (rte_eth_dev_socket_id(port) > 0 &&
369                                 rte_eth_dev_socket_id(port) != socket_id)
370                         printf("WARNING, port %u is on remote NUMA node to "
371                                         "TX thread.\n\tPerformance will not "
372                                         "be optimal.\n", port);
373         }
374
375         printf("\nCore %u doing packet TX.\n", rte_lcore_id());
376         while (!quit_signal) {
377
378                 for (port = 0; port < nb_ports; port++) {
379                         /* skip ports that are not enabled */
380                         if ((enabled_port_mask & (1 << port)) == 0)
381                                 continue;
382
383                         struct rte_mbuf *bufs[BURST_SIZE_TX];
384                         const uint16_t nb_rx = rte_ring_dequeue_burst(in_r,
385                                         (void *)bufs, BURST_SIZE_TX, NULL);
386                         app_stats.tx.dequeue_pkts += nb_rx;
387
388                         /* if we get no traffic, flush anything we have */
389                         if (unlikely(nb_rx == 0)) {
390                                 flush_all_ports(tx_buffers, nb_ports);
391                                 continue;
392                         }
393
394                         /* for traffic we receive, queue it up for transmit */
395                         uint16_t i;
396                         rte_prefetch_non_temporal((void *)bufs[0]);
397                         rte_prefetch_non_temporal((void *)bufs[1]);
398                         rte_prefetch_non_temporal((void *)bufs[2]);
399                         for (i = 0; i < nb_rx; i++) {
400                                 struct output_buffer *outbuf;
401                                 uint8_t outp;
402                                 rte_prefetch_non_temporal((void *)bufs[i + 3]);
403                                 /*
404                                  * workers should update in_port to hold the
405                                  * output port value
406                                  */
407                                 outp = bufs[i]->port;
408                                 /* skip ports that are not enabled */
409                                 if ((enabled_port_mask & (1 << outp)) == 0)
410                                         continue;
411
412                                 outbuf = &tx_buffers[outp];
413                                 outbuf->mbufs[outbuf->count++] = bufs[i];
414                                 if (outbuf->count == BURST_SIZE_TX)
415                                         flush_one_port(outbuf, outp);
416                         }
417                 }
418         }
419         printf("\nCore %u exiting tx task.\n", rte_lcore_id());
420         return 0;
421 }
422
423 static void
424 int_handler(int sig_num)
425 {
426         printf("Exiting on signal %d\n", sig_num);
427         /* set quit flag for rx thread to exit */
428         quit_signal_dist = 1;
429 }
430
431 static void
432 print_stats(void)
433 {
434         struct rte_eth_stats eth_stats;
435         unsigned int i, j;
436         const unsigned int num_workers = rte_lcore_count() - 4;
437
438         for (i = 0; i < rte_eth_dev_count(); i++) {
439                 rte_eth_stats_get(i, &eth_stats);
440                 app_stats.port_rx_pkts[i] = eth_stats.ipackets;
441                 app_stats.port_tx_pkts[i] = eth_stats.opackets;
442         }
443
444         printf("\n\nRX Thread:\n");
445         for (i = 0; i < rte_eth_dev_count(); i++) {
446                 printf("Port %u Pktsin : %5.2f\n", i,
447                                 (app_stats.port_rx_pkts[i] -
448                                 prev_app_stats.port_rx_pkts[i])/1000000.0);
449                 prev_app_stats.port_rx_pkts[i] = app_stats.port_rx_pkts[i];
450         }
451         printf(" - Received:    %5.2f\n",
452                         (app_stats.rx.rx_pkts -
453                         prev_app_stats.rx.rx_pkts)/1000000.0);
454         printf(" - Returned:    %5.2f\n",
455                         (app_stats.rx.returned_pkts -
456                         prev_app_stats.rx.returned_pkts)/1000000.0);
457         printf(" - Enqueued:    %5.2f\n",
458                         (app_stats.rx.enqueued_pkts -
459                         prev_app_stats.rx.enqueued_pkts)/1000000.0);
460         printf(" - Dropped:     %s%5.2f%s\n", ANSI_COLOR_RED,
461                         (app_stats.rx.enqdrop_pkts -
462                         prev_app_stats.rx.enqdrop_pkts)/1000000.0,
463                         ANSI_COLOR_RESET);
464
465         printf("Distributor thread:\n");
466         printf(" - In:          %5.2f\n",
467                         (app_stats.dist.in_pkts -
468                         prev_app_stats.dist.in_pkts)/1000000.0);
469         printf(" - Returned:    %5.2f\n",
470                         (app_stats.dist.ret_pkts -
471                         prev_app_stats.dist.ret_pkts)/1000000.0);
472         printf(" - Sent:        %5.2f\n",
473                         (app_stats.dist.sent_pkts -
474                         prev_app_stats.dist.sent_pkts)/1000000.0);
475         printf(" - Dropped      %s%5.2f%s\n", ANSI_COLOR_RED,
476                         (app_stats.dist.enqdrop_pkts -
477                         prev_app_stats.dist.enqdrop_pkts)/1000000.0,
478                         ANSI_COLOR_RESET);
479
480         printf("TX thread:\n");
481         printf(" - Dequeued:    %5.2f\n",
482                         (app_stats.tx.dequeue_pkts -
483                         prev_app_stats.tx.dequeue_pkts)/1000000.0);
484         for (i = 0; i < rte_eth_dev_count(); i++) {
485                 printf("Port %u Pktsout: %5.2f\n",
486                                 i, (app_stats.port_tx_pkts[i] -
487                                 prev_app_stats.port_tx_pkts[i])/1000000.0);
488                 prev_app_stats.port_tx_pkts[i] = app_stats.port_tx_pkts[i];
489         }
490         printf(" - Transmitted: %5.2f\n",
491                         (app_stats.tx.tx_pkts -
492                         prev_app_stats.tx.tx_pkts)/1000000.0);
493         printf(" - Dropped:     %s%5.2f%s\n", ANSI_COLOR_RED,
494                         (app_stats.tx.enqdrop_pkts -
495                         prev_app_stats.tx.enqdrop_pkts)/1000000.0,
496                         ANSI_COLOR_RESET);
497
498         prev_app_stats.rx.rx_pkts = app_stats.rx.rx_pkts;
499         prev_app_stats.rx.returned_pkts = app_stats.rx.returned_pkts;
500         prev_app_stats.rx.enqueued_pkts = app_stats.rx.enqueued_pkts;
501         prev_app_stats.rx.enqdrop_pkts = app_stats.rx.enqdrop_pkts;
502         prev_app_stats.dist.in_pkts = app_stats.dist.in_pkts;
503         prev_app_stats.dist.ret_pkts = app_stats.dist.ret_pkts;
504         prev_app_stats.dist.sent_pkts = app_stats.dist.sent_pkts;
505         prev_app_stats.dist.enqdrop_pkts = app_stats.dist.enqdrop_pkts;
506         prev_app_stats.tx.dequeue_pkts = app_stats.tx.dequeue_pkts;
507         prev_app_stats.tx.tx_pkts = app_stats.tx.tx_pkts;
508         prev_app_stats.tx.enqdrop_pkts = app_stats.tx.enqdrop_pkts;
509
510         for (i = 0; i < num_workers; i++) {
511                 printf("Worker %02u Pkts: %5.2f. Bursts(1-8): ", i,
512                                 (app_stats.worker_pkts[i] -
513                                 prev_app_stats.worker_pkts[i])/1000000.0);
514                 for (j = 0; j < 8; j++) {
515                         printf("%"PRIu64" ", app_stats.worker_bursts[i][j]);
516                         app_stats.worker_bursts[i][j] = 0;
517                 }
518                 printf("\n");
519                 prev_app_stats.worker_pkts[i] = app_stats.worker_pkts[i];
520         }
521 }
522
523 static int
524 lcore_worker(struct lcore_params *p)
525 {
526         struct rte_distributor *d = p->d;
527         const unsigned id = p->worker_id;
528         unsigned int num = 0;
529         unsigned int i;
530
531         /*
532          * for single port, xor_val will be zero so we won't modify the output
533          * port, otherwise we send traffic from 0 to 1, 2 to 3, and vice versa
534          */
535         const unsigned xor_val = (rte_eth_dev_count() > 1);
536         struct rte_mbuf *buf[8] __rte_cache_aligned;
537
538         for (i = 0; i < 8; i++)
539                 buf[i] = NULL;
540
541         app_stats.worker_pkts[p->worker_id] = 1;
542
543         printf("\nCore %u acting as worker core.\n", rte_lcore_id());
544         while (!quit_signal_work) {
545                 num = rte_distributor_get_pkt(d, id, buf, buf, num);
546                 /* Do a little bit of work for each packet */
547                 for (i = 0; i < num; i++) {
548                         uint64_t t = rte_rdtsc()+100;
549
550                         while (rte_rdtsc() < t)
551                                 rte_pause();
552                         buf[i]->port ^= xor_val;
553                 }
554
555                 app_stats.worker_pkts[p->worker_id] += num;
556                 if (num > 0)
557                         app_stats.worker_bursts[p->worker_id][num-1]++;
558         }
559         return 0;
560 }
561
562 /* display usage */
563 static void
564 print_usage(const char *prgname)
565 {
566         printf("%s [EAL options] -- -p PORTMASK\n"
567                         "  -p PORTMASK: hexadecimal bitmask of ports to configure\n",
568                         prgname);
569 }
570
571 static int
572 parse_portmask(const char *portmask)
573 {
574         char *end = NULL;
575         unsigned long pm;
576
577         /* parse hexadecimal string */
578         pm = strtoul(portmask, &end, 16);
579         if ((portmask[0] == '\0') || (end == NULL) || (*end != '\0'))
580                 return -1;
581
582         if (pm == 0)
583                 return -1;
584
585         return pm;
586 }
587
588 /* Parse the argument given in the command line of the application */
589 static int
590 parse_args(int argc, char **argv)
591 {
592         int opt;
593         char **argvopt;
594         int option_index;
595         char *prgname = argv[0];
596         static struct option lgopts[] = {
597                 {NULL, 0, 0, 0}
598         };
599
600         argvopt = argv;
601
602         while ((opt = getopt_long(argc, argvopt, "p:",
603                         lgopts, &option_index)) != EOF) {
604
605                 switch (opt) {
606                 /* portmask */
607                 case 'p':
608                         enabled_port_mask = parse_portmask(optarg);
609                         if (enabled_port_mask == 0) {
610                                 printf("invalid portmask\n");
611                                 print_usage(prgname);
612                                 return -1;
613                         }
614                         break;
615
616                 default:
617                         print_usage(prgname);
618                         return -1;
619                 }
620         }
621
622         if (optind <= 1) {
623                 print_usage(prgname);
624                 return -1;
625         }
626
627         argv[optind-1] = prgname;
628
629         optind = 1; /* reset getopt lib */
630         return 0;
631 }
632
633 /* Main function, does initialization and calls the per-lcore functions */
634 int
635 main(int argc, char *argv[])
636 {
637         struct rte_mempool *mbuf_pool;
638         struct rte_distributor *d;
639         struct rte_ring *dist_tx_ring;
640         struct rte_ring *rx_dist_ring;
641         unsigned lcore_id, worker_id = 0;
642         unsigned nb_ports;
643         uint16_t portid;
644         uint16_t nb_ports_available;
645         uint64_t t, freq;
646
647         /* catch ctrl-c so we can print on exit */
648         signal(SIGINT, int_handler);
649
650         /* init EAL */
651         int ret = rte_eal_init(argc, argv);
652         if (ret < 0)
653                 rte_exit(EXIT_FAILURE, "Error with EAL initialization\n");
654         argc -= ret;
655         argv += ret;
656
657         /* parse application arguments (after the EAL ones) */
658         ret = parse_args(argc, argv);
659         if (ret < 0)
660                 rte_exit(EXIT_FAILURE, "Invalid distributor parameters\n");
661
662         if (rte_lcore_count() < 5)
663                 rte_exit(EXIT_FAILURE, "Error, This application needs at "
664                                 "least 5 logical cores to run:\n"
665                                 "1 lcore for stats (can be core 0)\n"
666                                 "1 lcore for packet RX\n"
667                                 "1 lcore for distribution\n"
668                                 "1 lcore for packet TX\n"
669                                 "and at least 1 lcore for worker threads\n");
670
671         nb_ports = rte_eth_dev_count();
672         if (nb_ports == 0)
673                 rte_exit(EXIT_FAILURE, "Error: no ethernet ports detected\n");
674         if (nb_ports != 1 && (nb_ports & 1))
675                 rte_exit(EXIT_FAILURE, "Error: number of ports must be even, except "
676                                 "when using a single port\n");
677
678         mbuf_pool = rte_pktmbuf_pool_create("MBUF_POOL",
679                 NUM_MBUFS * nb_ports, MBUF_CACHE_SIZE, 0,
680                 RTE_MBUF_DEFAULT_BUF_SIZE, rte_socket_id());
681         if (mbuf_pool == NULL)
682                 rte_exit(EXIT_FAILURE, "Cannot create mbuf pool\n");
683         nb_ports_available = nb_ports;
684
685         /* initialize all ports */
686         for (portid = 0; portid < nb_ports; portid++) {
687                 /* skip ports that are not enabled */
688                 if ((enabled_port_mask & (1 << portid)) == 0) {
689                         printf("\nSkipping disabled port %d\n", portid);
690                         nb_ports_available--;
691                         continue;
692                 }
693                 /* init port */
694                 printf("Initializing port %u... done\n", portid);
695
696                 if (port_init(portid, mbuf_pool) != 0)
697                         rte_exit(EXIT_FAILURE, "Cannot initialize port %u\n",
698                                         portid);
699         }
700
701         if (!nb_ports_available) {
702                 rte_exit(EXIT_FAILURE,
703                                 "All available ports are disabled. Please set portmask.\n");
704         }
705
706         d = rte_distributor_create("PKT_DIST", rte_socket_id(),
707                         rte_lcore_count() - 4,
708                         RTE_DIST_ALG_BURST);
709         if (d == NULL)
710                 rte_exit(EXIT_FAILURE, "Cannot create distributor\n");
711
712         /*
713          * scheduler ring is read by the transmitter core, and written to
714          * by scheduler core
715          */
716         dist_tx_ring = rte_ring_create("Output_ring", SCHED_TX_RING_SZ,
717                         rte_socket_id(), RING_F_SC_DEQ | RING_F_SP_ENQ);
718         if (dist_tx_ring == NULL)
719                 rte_exit(EXIT_FAILURE, "Cannot create output ring\n");
720
721         rx_dist_ring = rte_ring_create("Input_ring", SCHED_RX_RING_SZ,
722                         rte_socket_id(), RING_F_SC_DEQ | RING_F_SP_ENQ);
723         if (rx_dist_ring == NULL)
724                 rte_exit(EXIT_FAILURE, "Cannot create output ring\n");
725
726         RTE_LCORE_FOREACH_SLAVE(lcore_id) {
727                 if (worker_id == rte_lcore_count() - 3) {
728                         printf("Starting distributor on lcore_id %d\n",
729                                         lcore_id);
730                         /* distributor core */
731                         struct lcore_params *p =
732                                         rte_malloc(NULL, sizeof(*p), 0);
733                         if (!p)
734                                 rte_panic("malloc failure\n");
735                         *p = (struct lcore_params){worker_id, d,
736                                 rx_dist_ring, dist_tx_ring, mbuf_pool};
737                         rte_eal_remote_launch(
738                                 (lcore_function_t *)lcore_distributor,
739                                 p, lcore_id);
740                 } else if (worker_id == rte_lcore_count() - 4) {
741                         printf("Starting tx  on worker_id %d, lcore_id %d\n",
742                                         worker_id, lcore_id);
743                         /* tx core */
744                         rte_eal_remote_launch((lcore_function_t *)lcore_tx,
745                                         dist_tx_ring, lcore_id);
746                 } else if (worker_id == rte_lcore_count() - 2) {
747                         printf("Starting rx on worker_id %d, lcore_id %d\n",
748                                         worker_id, lcore_id);
749                         /* rx core */
750                         struct lcore_params *p =
751                                         rte_malloc(NULL, sizeof(*p), 0);
752                         if (!p)
753                                 rte_panic("malloc failure\n");
754                         *p = (struct lcore_params){worker_id, d, rx_dist_ring,
755                                         dist_tx_ring, mbuf_pool};
756                         rte_eal_remote_launch((lcore_function_t *)lcore_rx,
757                                         p, lcore_id);
758                 } else {
759                         printf("Starting worker on worker_id %d, lcore_id %d\n",
760                                         worker_id, lcore_id);
761                         struct lcore_params *p =
762                                         rte_malloc(NULL, sizeof(*p), 0);
763                         if (!p)
764                                 rte_panic("malloc failure\n");
765                         *p = (struct lcore_params){worker_id, d, rx_dist_ring,
766                                         dist_tx_ring, mbuf_pool};
767
768                         rte_eal_remote_launch((lcore_function_t *)lcore_worker,
769                                         p, lcore_id);
770                 }
771                 worker_id++;
772         }
773
774         freq = rte_get_timer_hz();
775         t = rte_rdtsc() + freq;
776         while (!quit_signal_dist) {
777                 if (t < rte_rdtsc()) {
778                         print_stats();
779                         t = rte_rdtsc() + freq;
780                 }
781                 usleep(1000);
782         }
783
784         RTE_LCORE_FOREACH_SLAVE(lcore_id) {
785                 if (rte_eal_wait_lcore(lcore_id) < 0)
786                         return -1;
787         }
788
789         print_stats();
790         return 0;
791 }