4 * Copyright(c) 2010-2014 Intel Corporation. All rights reserved.
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
11 * * Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * * Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in
15 * the documentation and/or other materials provided with the
17 * * Neither the name of Intel Corporation nor the names of its
18 * contributors may be used to endorse or promote products derived
19 * from this software without specific prior written permission.
21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
24 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
25 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
26 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
27 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
28 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
29 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
30 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
31 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
38 #include <sys/types.h>
40 #include <sys/queue.h>
45 #include <rte_common.h>
46 #include <rte_byteorder.h>
48 #include <rte_memory.h>
49 #include <rte_memcpy.h>
50 #include <rte_memzone.h>
52 #include <rte_launch.h>
53 #include <rte_atomic.h>
54 #include <rte_cycles.h>
55 #include <rte_prefetch.h>
56 #include <rte_lcore.h>
57 #include <rte_per_lcore.h>
58 #include <rte_branch_prediction.h>
59 #include <rte_interrupts.h>
61 #include <rte_random.h>
62 #include <rte_debug.h>
63 #include <rte_ether.h>
64 #include <rte_ethdev.h>
65 #include <rte_mempool.h>
70 #include <rte_string_fns.h>
74 struct app_params app;
76 static const char usage[] =
78 " load_balancer <EAL PARAMS> -- <APP PARAMS> \n"
80 "Application manadatory parameters: \n"
81 " --rx \"(PORT, QUEUE, LCORE), ...\" : List of NIC RX ports and queues \n"
82 " handled by the I/O RX lcores \n"
83 " --tx \"(PORT, LCORE), ...\" : List of NIC TX ports handled by the I/O TX \n"
85 " --w \"LCORE, ...\" : List of the worker lcores \n"
86 " --lpm \"IP / PREFIX => PORT; ...\" : List of LPM rules used by the worker \n"
87 " lcores for packet forwarding \n"
89 "Application optional parameters: \n"
90 " --rsz \"A, B, C, D\" : Ring sizes \n"
91 " A = Size (in number of buffer descriptors) of each of the NIC RX \n"
92 " rings read by the I/O RX lcores (default value is %u) \n"
93 " B = Size (in number of elements) of each of the SW rings used by the\n"
94 " I/O RX lcores to send packets to worker lcores (default value is\n"
96 " C = Size (in number of elements) of each of the SW rings used by the\n"
97 " worker lcores to send packets to I/O TX lcores (default value is\n"
99 " D = Size (in number of buffer descriptors) of each of the NIC TX \n"
100 " rings written by I/O TX lcores (default value is %u) \n"
101 " --bsz \"(A, B), (C, D), (E, F)\" : Burst sizes \n"
102 " A = I/O RX lcore read burst size from NIC RX (default value is %u) \n"
103 " B = I/O RX lcore write burst size to output SW rings (default value \n"
105 " C = Worker lcore read burst size from input SW rings (default value \n"
107 " D = Worker lcore write burst size to output SW rings (default value \n"
109 " E = I/O TX lcore read burst size from input SW rings (default value \n"
111 " F = I/O TX lcore write burst size to NIC TX (default value is %u) \n"
112 " --pos-lb POS : Position of the 1-byte field within the input packet used by\n"
113 " the I/O RX lcores to identify the worker lcore for the current \n"
114 " packet (default value is %u) \n";
117 app_print_usage(void)
120 APP_DEFAULT_NIC_RX_RING_SIZE,
121 APP_DEFAULT_RING_RX_SIZE,
122 APP_DEFAULT_RING_TX_SIZE,
123 APP_DEFAULT_NIC_TX_RING_SIZE,
124 APP_DEFAULT_BURST_SIZE_IO_RX_READ,
125 APP_DEFAULT_BURST_SIZE_IO_RX_WRITE,
126 APP_DEFAULT_BURST_SIZE_WORKER_READ,
127 APP_DEFAULT_BURST_SIZE_WORKER_WRITE,
128 APP_DEFAULT_BURST_SIZE_IO_TX_READ,
129 APP_DEFAULT_BURST_SIZE_IO_TX_WRITE,
130 APP_DEFAULT_IO_RX_LB_POS
134 #ifndef APP_ARG_RX_MAX_CHARS
135 #define APP_ARG_RX_MAX_CHARS 4096
138 #ifndef APP_ARG_RX_MAX_TUPLES
139 #define APP_ARG_RX_MAX_TUPLES 128
143 str_to_unsigned_array(
144 const char *s, size_t sbuflen,
150 char *splits[num_vals];
152 int i, num_splits = 0;
154 /* copy s so we don't modify original string */
155 snprintf(str, sizeof(str), "%s", s);
156 num_splits = rte_strsplit(str, sizeof(str), splits, num_vals, separator);
159 for (i = 0; i < num_splits; i++) {
160 vals[i] = strtoul(splits[i], &endptr, 0);
161 if (errno != 0 || *endptr != '\0')
169 str_to_unsigned_vals(
173 unsigned num_vals, ...)
175 unsigned i, vals[num_vals];
178 num_vals = str_to_unsigned_array(s, sbuflen, separator, num_vals, vals);
180 va_start(ap, num_vals);
181 for (i = 0; i < num_vals; i++) {
182 unsigned *u = va_arg(ap, unsigned *);
190 parse_arg_rx(const char *arg)
192 const char *p0 = arg, *p = arg;
195 if (strnlen(arg, APP_ARG_RX_MAX_CHARS + 1) == APP_ARG_RX_MAX_CHARS + 1) {
200 while ((p = strchr(p0,'(')) != NULL) {
201 struct app_lcore_params *lp;
202 uint32_t port, queue, lcore, i;
204 p0 = strchr(p++, ')');
206 (str_to_unsigned_vals(p, p0 - p, ',', 3, &port, &queue, &lcore) != 3)) {
210 /* Enable port and queue for later initialization */
211 if ((port >= APP_MAX_NIC_PORTS) || (queue >= APP_MAX_RX_QUEUES_PER_NIC_PORT)) {
214 if (app.nic_rx_queue_mask[port][queue] != 0) {
217 app.nic_rx_queue_mask[port][queue] = 1;
219 /* Check and assign (port, queue) to I/O lcore */
220 if (rte_lcore_is_enabled(lcore) == 0) {
224 if (lcore >= APP_MAX_LCORES) {
227 lp = &app.lcore_params[lcore];
228 if (lp->type == e_APP_LCORE_WORKER) {
231 lp->type = e_APP_LCORE_IO;
232 const size_t n_queues = RTE_MIN(lp->io.rx.n_nic_queues,
233 RTE_DIM(lp->io.rx.nic_queues));
234 for (i = 0; i < n_queues; i ++) {
235 if ((lp->io.rx.nic_queues[i].port == port) &&
236 (lp->io.rx.nic_queues[i].queue == queue)) {
240 if (lp->io.rx.n_nic_queues >= APP_MAX_NIC_RX_QUEUES_PER_IO_LCORE) {
243 lp->io.rx.nic_queues[lp->io.rx.n_nic_queues].port = port;
244 lp->io.rx.nic_queues[lp->io.rx.n_nic_queues].queue = (uint8_t) queue;
245 lp->io.rx.n_nic_queues ++;
248 if (n_tuples > APP_ARG_RX_MAX_TUPLES) {
260 #ifndef APP_ARG_TX_MAX_CHARS
261 #define APP_ARG_TX_MAX_CHARS 4096
264 #ifndef APP_ARG_TX_MAX_TUPLES
265 #define APP_ARG_TX_MAX_TUPLES 128
269 parse_arg_tx(const char *arg)
271 const char *p0 = arg, *p = arg;
274 if (strnlen(arg, APP_ARG_TX_MAX_CHARS + 1) == APP_ARG_TX_MAX_CHARS + 1) {
279 while ((p = strchr(p0,'(')) != NULL) {
280 struct app_lcore_params *lp;
281 uint32_t port, lcore, i;
283 p0 = strchr(p++, ')');
285 (str_to_unsigned_vals(p, p0 - p, ',', 2, &port, &lcore) != 2)) {
289 /* Enable port and queue for later initialization */
290 if (port >= APP_MAX_NIC_PORTS) {
293 if (app.nic_tx_port_mask[port] != 0) {
296 app.nic_tx_port_mask[port] = 1;
298 /* Check and assign (port, queue) to I/O lcore */
299 if (rte_lcore_is_enabled(lcore) == 0) {
303 if (lcore >= APP_MAX_LCORES) {
306 lp = &app.lcore_params[lcore];
307 if (lp->type == e_APP_LCORE_WORKER) {
310 lp->type = e_APP_LCORE_IO;
311 const size_t n_ports = RTE_MIN(lp->io.tx.n_nic_ports,
312 RTE_DIM(lp->io.tx.nic_ports));
313 for (i = 0; i < n_ports; i ++) {
314 if (lp->io.tx.nic_ports[i] == port) {
318 if (lp->io.tx.n_nic_ports >= APP_MAX_NIC_TX_PORTS_PER_IO_LCORE) {
321 lp->io.tx.nic_ports[lp->io.tx.n_nic_ports] = port;
322 lp->io.tx.n_nic_ports ++;
325 if (n_tuples > APP_ARG_TX_MAX_TUPLES) {
337 #ifndef APP_ARG_W_MAX_CHARS
338 #define APP_ARG_W_MAX_CHARS 4096
341 #ifndef APP_ARG_W_MAX_TUPLES
342 #define APP_ARG_W_MAX_TUPLES APP_MAX_WORKER_LCORES
346 parse_arg_w(const char *arg)
351 if (strnlen(arg, APP_ARG_W_MAX_CHARS + 1) == APP_ARG_W_MAX_CHARS + 1) {
357 struct app_lcore_params *lp;
361 lcore = strtoul(p, NULL, 0);
366 /* Check and enable worker lcore */
367 if (rte_lcore_is_enabled(lcore) == 0) {
371 if (lcore >= APP_MAX_LCORES) {
374 lp = &app.lcore_params[lcore];
375 if (lp->type == e_APP_LCORE_IO) {
378 lp->type = e_APP_LCORE_WORKER;
381 if (n_tuples > APP_ARG_W_MAX_TUPLES) {
396 if ((n_tuples & (n_tuples - 1)) != 0) {
403 #ifndef APP_ARG_LPM_MAX_CHARS
404 #define APP_ARG_LPM_MAX_CHARS 4096
408 parse_arg_lpm(const char *arg)
410 const char *p = arg, *p0;
412 if (strnlen(arg, APP_ARG_LPM_MAX_CHARS + 1) == APP_ARG_TX_MAX_CHARS + 1) {
417 uint32_t ip_a, ip_b, ip_c, ip_d, ip, depth, if_out;
422 (str_to_unsigned_vals(p, p0 - p, '.', 4, &ip_a, &ip_b, &ip_c, &ip_d) != 4)) {
428 depth = strtoul(p, &endptr, 0);
429 if (errno != 0 || *endptr != '=') {
436 if_out = strtoul(++p, &endptr, 0);
437 if (errno != 0 || (*endptr != '\0' && *endptr != ';')) {
441 if ((ip_a >= 256) || (ip_b >= 256) || (ip_c >= 256) || (ip_d >= 256) ||
442 (depth == 0) || (depth >= 32) ||
443 (if_out >= APP_MAX_NIC_PORTS)) {
446 ip = (ip_a << 24) | (ip_b << 16) | (ip_c << 8) | ip_d;
448 if (app.n_lpm_rules >= APP_MAX_LPM_RULES) {
451 app.lpm_rules[app.n_lpm_rules].ip = ip;
452 app.lpm_rules[app.n_lpm_rules].depth = (uint8_t) depth;
453 app.lpm_rules[app.n_lpm_rules].if_out = (uint8_t) if_out;
463 if (app.n_lpm_rules == 0) {
471 app_check_lpm_table(void)
475 /* For each rule, check that the output I/F is enabled */
476 for (rule = 0; rule < app.n_lpm_rules; rule ++)
478 uint32_t port = app.lpm_rules[rule].if_out;
480 if (app.nic_tx_port_mask[port] == 0) {
489 app_check_every_rx_port_is_tx_enabled(void)
493 for (port = 0; port < APP_MAX_NIC_PORTS; port ++) {
494 if ((app_get_nic_rx_queues_per_port(port) > 0) && (app.nic_tx_port_mask[port] == 0)) {
502 #ifndef APP_ARG_RSZ_CHARS
503 #define APP_ARG_RSZ_CHARS 63
507 parse_arg_rsz(const char *arg)
509 if (strnlen(arg, APP_ARG_RSZ_CHARS + 1) == APP_ARG_RSZ_CHARS + 1) {
513 if (str_to_unsigned_vals(arg, APP_ARG_RSZ_CHARS, ',', 4,
514 &app.nic_rx_ring_size,
517 &app.nic_tx_ring_size) != 4)
521 if ((app.nic_rx_ring_size == 0) ||
522 (app.nic_tx_ring_size == 0) ||
523 (app.ring_rx_size == 0) ||
524 (app.ring_tx_size == 0)) {
531 #ifndef APP_ARG_BSZ_CHARS
532 #define APP_ARG_BSZ_CHARS 63
536 parse_arg_bsz(const char *arg)
538 const char *p = arg, *p0;
539 if (strnlen(arg, APP_ARG_BSZ_CHARS + 1) == APP_ARG_BSZ_CHARS + 1) {
543 p0 = strchr(p++, ')');
545 (str_to_unsigned_vals(p, p0 - p, ',', 2, &app.burst_size_io_rx_read, &app.burst_size_io_rx_write) != 2)) {
554 p0 = strchr(p++, ')');
556 (str_to_unsigned_vals(p, p0 - p, ',', 2, &app.burst_size_worker_read, &app.burst_size_worker_write) != 2)) {
565 p0 = strchr(p++, ')');
567 (str_to_unsigned_vals(p, p0 - p, ',', 2, &app.burst_size_io_tx_read, &app.burst_size_io_tx_write) != 2)) {
571 if ((app.burst_size_io_rx_read == 0) ||
572 (app.burst_size_io_rx_write == 0) ||
573 (app.burst_size_worker_read == 0) ||
574 (app.burst_size_worker_write == 0) ||
575 (app.burst_size_io_tx_read == 0) ||
576 (app.burst_size_io_tx_write == 0)) {
580 if ((app.burst_size_io_rx_read > APP_MBUF_ARRAY_SIZE) ||
581 (app.burst_size_io_rx_write > APP_MBUF_ARRAY_SIZE) ||
582 (app.burst_size_worker_read > APP_MBUF_ARRAY_SIZE) ||
583 (app.burst_size_worker_write > APP_MBUF_ARRAY_SIZE) ||
584 ((2 * app.burst_size_io_tx_read) > APP_MBUF_ARRAY_SIZE) ||
585 (app.burst_size_io_tx_write > APP_MBUF_ARRAY_SIZE)) {
592 #ifndef APP_ARG_NUMERICAL_SIZE_CHARS
593 #define APP_ARG_NUMERICAL_SIZE_CHARS 15
597 parse_arg_pos_lb(const char *arg)
602 if (strnlen(arg, APP_ARG_NUMERICAL_SIZE_CHARS + 1) == APP_ARG_NUMERICAL_SIZE_CHARS + 1) {
607 x = strtoul(arg, &endpt, 10);
608 if (errno != 0 || endpt == arg || *endpt != '\0'){
616 app.pos_lb = (uint8_t) x;
621 /* Parse the argument given in the command line of the application */
623 app_parse_args(int argc, char **argv)
628 char *prgname = argv[0];
629 static struct option lgopts[] = {
642 uint32_t arg_lpm = 0;
643 uint32_t arg_rsz = 0;
644 uint32_t arg_bsz = 0;
645 uint32_t arg_pos_lb = 0;
649 while ((opt = getopt_long(argc, argvopt, "",
650 lgopts, &option_index)) != EOF) {
655 if (!strcmp(lgopts[option_index].name, "rx")) {
657 ret = parse_arg_rx(optarg);
659 printf("Incorrect value for --rx argument (%d)\n", ret);
663 if (!strcmp(lgopts[option_index].name, "tx")) {
665 ret = parse_arg_tx(optarg);
667 printf("Incorrect value for --tx argument (%d)\n", ret);
671 if (!strcmp(lgopts[option_index].name, "w")) {
673 ret = parse_arg_w(optarg);
675 printf("Incorrect value for --w argument (%d)\n", ret);
679 if (!strcmp(lgopts[option_index].name, "lpm")) {
681 ret = parse_arg_lpm(optarg);
683 printf("Incorrect value for --lpm argument (%d)\n", ret);
687 if (!strcmp(lgopts[option_index].name, "rsz")) {
689 ret = parse_arg_rsz(optarg);
691 printf("Incorrect value for --rsz argument (%d)\n", ret);
695 if (!strcmp(lgopts[option_index].name, "bsz")) {
697 ret = parse_arg_bsz(optarg);
699 printf("Incorrect value for --bsz argument (%d)\n", ret);
703 if (!strcmp(lgopts[option_index].name, "pos-lb")) {
705 ret = parse_arg_pos_lb(optarg);
707 printf("Incorrect value for --pos-lb argument (%d)\n", ret);
718 /* Check that all mandatory arguments are provided */
719 if ((arg_rx == 0) || (arg_tx == 0) || (arg_w == 0) || (arg_lpm == 0)){
720 printf("Not all mandatory arguments are present\n");
724 /* Assign default values for the optional arguments not provided */
726 app.nic_rx_ring_size = APP_DEFAULT_NIC_RX_RING_SIZE;
727 app.nic_tx_ring_size = APP_DEFAULT_NIC_TX_RING_SIZE;
728 app.ring_rx_size = APP_DEFAULT_RING_RX_SIZE;
729 app.ring_tx_size = APP_DEFAULT_RING_TX_SIZE;
733 app.burst_size_io_rx_read = APP_DEFAULT_BURST_SIZE_IO_RX_READ;
734 app.burst_size_io_rx_write = APP_DEFAULT_BURST_SIZE_IO_RX_WRITE;
735 app.burst_size_io_tx_read = APP_DEFAULT_BURST_SIZE_IO_TX_READ;
736 app.burst_size_io_tx_write = APP_DEFAULT_BURST_SIZE_IO_TX_WRITE;
737 app.burst_size_worker_read = APP_DEFAULT_BURST_SIZE_WORKER_READ;
738 app.burst_size_worker_write = APP_DEFAULT_BURST_SIZE_WORKER_WRITE;
741 if (arg_pos_lb == 0) {
742 app.pos_lb = APP_DEFAULT_IO_RX_LB_POS;
745 /* Check cross-consistency of arguments */
746 if ((ret = app_check_lpm_table()) < 0) {
747 printf("At least one LPM rule is inconsistent (%d)\n", ret);
750 if (app_check_every_rx_port_is_tx_enabled() < 0) {
751 printf("On LPM lookup miss, packet is sent back on the input port.\n");
752 printf("At least one RX port is not enabled for TX.\n");
757 argv[optind - 1] = prgname;
760 optind = 1; /* reset getopt lib */
765 app_get_nic_rx_queues_per_port(uint16_t port)
769 if (port >= APP_MAX_NIC_PORTS) {
774 for (i = 0; i < APP_MAX_RX_QUEUES_PER_NIC_PORT; i ++) {
775 if (app.nic_rx_queue_mask[port][i] == 1) {
784 app_get_lcore_for_nic_rx(uint16_t port, uint8_t queue, uint32_t *lcore_out)
788 for (lcore = 0; lcore < APP_MAX_LCORES; lcore ++) {
789 struct app_lcore_params_io *lp = &app.lcore_params[lcore].io;
792 if (app.lcore_params[lcore].type != e_APP_LCORE_IO) {
796 const size_t n_queues = RTE_MIN(lp->rx.n_nic_queues,
797 RTE_DIM(lp->rx.nic_queues));
798 for (i = 0; i < n_queues; i ++) {
799 if ((lp->rx.nic_queues[i].port == port) &&
800 (lp->rx.nic_queues[i].queue == queue)) {
811 app_get_lcore_for_nic_tx(uint16_t port, uint32_t *lcore_out)
815 for (lcore = 0; lcore < APP_MAX_LCORES; lcore ++) {
816 struct app_lcore_params_io *lp = &app.lcore_params[lcore].io;
819 if (app.lcore_params[lcore].type != e_APP_LCORE_IO) {
823 const size_t n_ports = RTE_MIN(lp->tx.n_nic_ports,
824 RTE_DIM(lp->tx.nic_ports));
825 for (i = 0; i < n_ports; i ++) {
826 if (lp->tx.nic_ports[i] == port) {
837 app_is_socket_used(uint32_t socket)
841 for (lcore = 0; lcore < APP_MAX_LCORES; lcore ++) {
842 if (app.lcore_params[lcore].type == e_APP_LCORE_DISABLED) {
846 if (socket == rte_lcore_to_socket_id(lcore)) {
855 app_get_lcores_io_rx(void)
857 uint32_t lcore, count;
860 for (lcore = 0; lcore < APP_MAX_LCORES; lcore ++) {
861 struct app_lcore_params_io *lp_io = &app.lcore_params[lcore].io;
863 if ((app.lcore_params[lcore].type != e_APP_LCORE_IO) ||
864 (lp_io->rx.n_nic_queues == 0)) {
875 app_get_lcores_worker(void)
877 uint32_t lcore, count;
880 for (lcore = 0; lcore < APP_MAX_LCORES; lcore ++) {
881 if (app.lcore_params[lcore].type != e_APP_LCORE_WORKER) {
888 if (count > APP_MAX_WORKER_LCORES) {
889 rte_panic("Algorithmic error (too many worker lcores)\n");
897 app_print_params(void)
899 unsigned port, queue, lcore, rule, i, j;
901 /* Print NIC RX configuration */
902 printf("NIC RX ports: ");
903 for (port = 0; port < APP_MAX_NIC_PORTS; port ++) {
904 uint32_t n_rx_queues = app_get_nic_rx_queues_per_port(port);
906 if (n_rx_queues == 0) {
910 printf("%u (", port);
911 for (queue = 0; queue < APP_MAX_RX_QUEUES_PER_NIC_PORT; queue ++) {
912 if (app.nic_rx_queue_mask[port][queue] == 1) {
913 printf("%u ", queue);
920 /* Print I/O lcore RX params */
921 for (lcore = 0; lcore < APP_MAX_LCORES; lcore ++) {
922 struct app_lcore_params_io *lp = &app.lcore_params[lcore].io;
924 if ((app.lcore_params[lcore].type != e_APP_LCORE_IO) ||
925 (lp->rx.n_nic_queues == 0)) {
929 printf("I/O lcore %u (socket %u): ", lcore, rte_lcore_to_socket_id(lcore));
932 for (i = 0; i < lp->rx.n_nic_queues; i ++) {
934 (unsigned) lp->rx.nic_queues[i].port,
935 (unsigned) lp->rx.nic_queues[i].queue);
939 printf("Output rings ");
940 for (i = 0; i < lp->rx.n_rings; i ++) {
941 printf("%p ", lp->rx.rings[i]);
946 /* Print worker lcore RX params */
947 for (lcore = 0; lcore < APP_MAX_LCORES; lcore ++) {
948 struct app_lcore_params_worker *lp = &app.lcore_params[lcore].worker;
950 if (app.lcore_params[lcore].type != e_APP_LCORE_WORKER) {
954 printf("Worker lcore %u (socket %u) ID %u: ",
956 rte_lcore_to_socket_id(lcore),
957 (unsigned)lp->worker_id);
959 printf("Input rings ");
960 for (i = 0; i < lp->n_rings_in; i ++) {
961 printf("%p ", lp->rings_in[i]);
969 /* Print NIC TX configuration */
970 printf("NIC TX ports: ");
971 for (port = 0; port < APP_MAX_NIC_PORTS; port ++) {
972 if (app.nic_tx_port_mask[port] == 1) {
978 /* Print I/O TX lcore params */
979 for (lcore = 0; lcore < APP_MAX_LCORES; lcore ++) {
980 struct app_lcore_params_io *lp = &app.lcore_params[lcore].io;
981 uint32_t n_workers = app_get_lcores_worker();
983 if ((app.lcore_params[lcore].type != e_APP_LCORE_IO) ||
984 (lp->tx.n_nic_ports == 0)) {
988 printf("I/O lcore %u (socket %u): ", lcore, rte_lcore_to_socket_id(lcore));
990 printf("Input rings per TX port ");
991 for (i = 0; i < lp->tx.n_nic_ports; i ++) {
992 port = lp->tx.nic_ports[i];
994 printf("%u (", port);
995 for (j = 0; j < n_workers; j ++) {
996 printf("%p ", lp->tx.rings[port][j]);
1005 /* Print worker lcore TX params */
1006 for (lcore = 0; lcore < APP_MAX_LCORES; lcore ++) {
1007 struct app_lcore_params_worker *lp = &app.lcore_params[lcore].worker;
1009 if (app.lcore_params[lcore].type != e_APP_LCORE_WORKER) {
1013 printf("Worker lcore %u (socket %u) ID %u: \n",
1015 rte_lcore_to_socket_id(lcore),
1016 (unsigned)lp->worker_id);
1018 printf("Output rings per TX port ");
1019 for (port = 0; port < APP_MAX_NIC_PORTS; port ++) {
1020 if (lp->rings_out[port] != NULL) {
1021 printf("%u (%p) ", port, lp->rings_out[port]);
1028 /* Print LPM rules */
1029 printf("LPM rules: \n");
1030 for (rule = 0; rule < app.n_lpm_rules; rule ++) {
1031 uint32_t ip = app.lpm_rules[rule].ip;
1032 uint8_t depth = app.lpm_rules[rule].depth;
1033 uint8_t if_out = app.lpm_rules[rule].if_out;
1035 printf("\t%u: %u.%u.%u.%u/%u => %u;\n",
1037 (unsigned) (ip & 0xFF000000) >> 24,
1038 (unsigned) (ip & 0x00FF0000) >> 16,
1039 (unsigned) (ip & 0x0000FF00) >> 8,
1040 (unsigned) ip & 0x000000FF,
1047 printf("Ring sizes: NIC RX = %u; Worker in = %u; Worker out = %u; NIC TX = %u;\n",
1048 (unsigned) app.nic_rx_ring_size,
1049 (unsigned) app.ring_rx_size,
1050 (unsigned) app.ring_tx_size,
1051 (unsigned) app.nic_tx_ring_size);
1054 printf("Burst sizes: I/O RX (rd = %u, wr = %u); Worker (rd = %u, wr = %u); I/O TX (rd = %u, wr = %u)\n",
1055 (unsigned) app.burst_size_io_rx_read,
1056 (unsigned) app.burst_size_io_rx_write,
1057 (unsigned) app.burst_size_worker_read,
1058 (unsigned) app.burst_size_worker_write,
1059 (unsigned) app.burst_size_io_tx_read,
1060 (unsigned) app.burst_size_io_tx_write);