examples/multi_process/symmetric_mp/main.c

   1 /*-
   2  *   BSD LICENSE
   3  *
   4  *   Copyright(c) 2010-2012 Intel Corporation. All rights reserved.
   5  *   All rights reserved.
   6  *
   7  *   Redistribution and use in source and binary forms, with or without
   8  *   modification, are permitted provided that the following conditions
   9  *   are met:
  10  *
  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
  16  *       distribution.
  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.
  20  *
  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.
  32  *
  33  *  version: DPDK.L.1.2.3-3
  34  */
  35
  36 /*
  37  * Sample application demostrating how to do packet I/O in a multi-process
  38  * environment. The same code can be run as a primary process and as a
  39  * secondary process, just with a different proc-id parameter in each case
  40  * (apart from the EAL flag to indicate a secondary process).
  41  *
  42  * Each process will read from the same ports, given by the port-mask
  43  * parameter, which should be the same in each case, just using a different
  44  * queue per port as determined by the proc-id parameter.
  45  */
  46
  47 #include <stdio.h>
  48 #include <string.h>
  49 #include <stdint.h>
  50 #include <stdlib.h>
  51 #include <stdarg.h>
  52 #include <errno.h>
  53 #include <sys/queue.h>
  54 #include <getopt.h>
  55 #include <signal.h>
  56 #include <inttypes.h>
  57
  58 #include <rte_common.h>
  59 #include <rte_log.h>
  60 #include <rte_memory.h>
  61 #include <rte_memzone.h>
  62 #include <rte_launch.h>
  63 #include <rte_tailq.h>
  64 #include <rte_eal.h>
  65 #include <rte_per_lcore.h>
  66 #include <rte_lcore.h>
  67 #include <rte_debug.h>
  68 #include <rte_atomic.h>
  69 #include <rte_branch_prediction.h>
  70 #include <rte_ring.h>
  71 #include <rte_debug.h>
  72 #include <rte_interrupts.h>
  73 #include <rte_pci.h>
  74 #include <rte_ether.h>
  75 #include <rte_ethdev.h>
  76 #include <rte_mempool.h>
  77 #include <rte_memcpy.h>
  78 #include <rte_mbuf.h>
  79 #include <rte_string_fns.h>
  80
  81 #define RTE_LOGTYPE_APP RTE_LOGTYPE_USER1
  82
  83 #define SOCKET0 0
  84
  85 #define MBUF_SIZE (2048 + sizeof(struct rte_mbuf) + RTE_PKTMBUF_HEADROOM)
  86 #define NB_MBUFS 64*1024 /* use 64k mbufs */
  87 #define MBUF_CACHE_SIZE 256
  88 #define PKT_BURST 32
  89 #define RX_RING_SIZE 128
  90 #define TX_RING_SIZE 512
  91
  92 #define PARAM_PROC_ID "proc-id"
  93 #define PARAM_NUM_PROCS "num-procs"
  94
  95 /*
  96  * RX and TX Prefetch, Host, and Write-back threshold values should be
  97  * carefully set for optimal performance. Consult the network
  98  * controller's datasheet and supporting DPDK documentation for guidance
  99  * on how these parameters should be set.
 100  */
 101 /* Default configuration for rx and tx thresholds etc. */
 102 static const struct rte_eth_rxconf rx_conf_default = {
 103         .rx_thresh = {
 104                 .pthresh = 8,
 105                 .hthresh = 8,
 106                 .wthresh = 4,
 107         },
 108 };
 109
 110 /*
 111  * These default values are optimized for use with the Intel(R) 82599 10 GbE
 112  * Controller and the DPDK ixgbe PMD. Consider using other values for other
 113  * network controllers and/or network drivers.
 114  */
 115 static const struct rte_eth_txconf tx_conf_default = {
 116         .tx_thresh = {
 117                 .pthresh = 36,
 118                 .hthresh = 0,
 119                 .wthresh = 0,
 120         },
 121         .tx_free_thresh = 0, /* Use PMD default values */
 122         .tx_rs_thresh = 0, /* Use PMD default values */
 123 };
 124
 125 /* for each lcore, record the elements of the ports array to use */
 126 struct lcore_ports{
 127         unsigned start_port;
 128         unsigned num_ports;
 129 };
 130
 131 /* structure to record the rx and tx packets. Put two per cache line as ports
 132  * used in pairs */
 133 struct port_stats{
 134         unsigned rx;
 135         unsigned tx;
 136         unsigned drop;
 137 } __attribute__((aligned(CACHE_LINE_SIZE / 2)));
 138
 139 static int proc_id = -1;
 140 static unsigned num_procs = 0;
 141
 142 static uint8_t ports[RTE_MAX_ETHPORTS];
 143 static unsigned num_ports = 0;
 144
 145 static struct lcore_ports lcore_ports[RTE_MAX_LCORE];
 146 static struct port_stats pstats[RTE_MAX_ETHPORTS];
 147
 148 /* prints the usage statement and quits with an error message */
 149 static void
 150 smp_usage(const char *prgname, const char *errmsg)
 151 {
 152         printf("\nError: %s\n",errmsg);
 153         printf("\n%s [EAL options] -- -p <port mask> "
 154                         "--"PARAM_NUM_PROCS" <n>"
 155                         " --"PARAM_PROC_ID" <id>\n"
 156                         "-p         : a hex bitmask indicating what ports are to be used\n"
 157                         "--num-procs: the number of processes which will be used\n"
 158                         "--proc-id  : the id of the current process (id < num-procs)\n"
 159                         "\n",
 160                         prgname);
 161         exit(1);
 162 }
 163
 164
 165 /* signal handler configured for SIGTERM and SIGINT to print stats on exit */
 166 static void
 167 print_stats(int signum)
 168 {
 169         unsigned i;
 170         printf("\nExiting on signal %d\n\n", signum);
 171         for (i = 0; i < num_ports; i++){
 172                 const uint8_t p_num = ports[i];
 173                 printf("Port %u: RX - %u, TX - %u, Drop - %u\n", (unsigned)p_num,
 174                                 pstats[p_num].rx, pstats[p_num].tx, pstats[p_num].drop);
 175         }
 176         exit(0);
 177 }
 178
 179 /* Parse the argument given in the command line of the application */
 180 static int
 181 smp_parse_args(int argc, char **argv)
 182 {
 183         int opt, ret;
 184         char **argvopt;
 185         int option_index;
 186         unsigned i, port_mask = 0;
 187         char *prgname = argv[0];
 188         static struct option lgopts[] = {
 189                         {PARAM_NUM_PROCS, 1, 0, 0},
 190                         {PARAM_PROC_ID, 1, 0, 0},
 191                         {NULL, 0, 0, 0}
 192         };
 193
 194         argvopt = argv;
 195
 196         while ((opt = getopt_long(argc, argvopt, "p:", \
 197                         lgopts, &option_index)) != EOF) {
 198
 199                 switch (opt) {
 200                 case 'p':
 201                         port_mask = strtoull(optarg, NULL, 16);
 202                         break;
 203                         /* long options */
 204                 case 0:
 205                         if (strncmp(lgopts[option_index].name, PARAM_NUM_PROCS, 8) == 0)
 206                                 num_procs = atoi(optarg);
 207                         else if (strncmp(lgopts[option_index].name, PARAM_PROC_ID, 7) == 0)
 208                                 proc_id = atoi(optarg);
 209                         break;
 210
 211                 default:
 212                         smp_usage(prgname, "Cannot parse all command-line arguments\n");
 213                 }
 214         }
 215
 216         if (optind >= 0)
 217                 argv[optind-1] = prgname;
 218
 219         if (proc_id < 0)
 220                 smp_usage(prgname, "Invalid or missing proc-id parameter\n");
 221         if (rte_eal_process_type() == RTE_PROC_PRIMARY && num_procs == 0)
 222                 smp_usage(prgname, "Invalid or missing num-procs parameter\n");
 223         if (port_mask == 0)
 224                 smp_usage(prgname, "Invalid or missing port mask\n");
 225
 226         /* get the port numbers from the port mask */
 227         for(i = 0; i < rte_eth_dev_count(); i++)
 228                 if(port_mask & (1 << i))
 229                         ports[num_ports++] = (uint8_t)i;
 230
 231         ret = optind-1;
 232         optind = 0; /* reset getopt lib */
 233
 234         return (ret);
 235 }
 236
 237 /* Queries the link status of a port and prints it to screen */
 238 static void
 239 report_link_status(uint8_t port)
 240 {
 241         /* get link status */
 242         struct rte_eth_link link;
 243         rte_eth_link_get(port, &link);
 244         if (link.link_status)
 245                 printf("Port %u: Link Up - %u Gbps - %s\n", (unsigned)port,
 246                                 (unsigned) link.link_speed / 1000,
 247                                 (link.link_duplex == ETH_LINK_FULL_DUPLEX) ?
 248                                                 ("full-duplex") : ("half-duplex\n"));
 249         else
 250                 printf("Port %u: Link Down\n", (unsigned)port);
 251 }
 252
 253 /*
 254  * Initialises a given port using global settings and with the rx buffers
 255  * coming from the mbuf_pool passed as parameter
 256  */
 257 static inline int
 258 smp_port_init(uint8_t port, struct rte_mempool *mbuf_pool, uint16_t num_queues)
 259 {
 260         struct rte_eth_conf port_conf = {
 261                         .rxmode = {
 262                                 .mq_mode = ETH_RSS,
 263                                 .split_hdr_size = 0,
 264                                 .header_split   = 0, /**< Header Split disabled */
 265                                 .hw_ip_checksum = 1, /**< IP checksum offload enabled */
 266                                 .hw_vlan_filter = 0, /**< VLAN filtering disabled */
 267                                 .jumbo_frame    = 0, /**< Jumbo Frame Support disabled */
 268                                 .hw_strip_crc   = 0, /**< CRC stripped by hardware */
 269                         },
 270                         .rx_adv_conf = {
 271                                 .rss_conf = {
 272                                         .rss_key = NULL,
 273                                         .rss_hf = ETH_RSS_IPV4,
 274                                 },
 275                         },
 276                         .txmode = {
 277                         }
 278         };
 279         const uint16_t rx_rings = num_queues, tx_rings = num_queues;
 280         int retval;
 281         uint16_t q;
 282
 283         if (rte_eal_process_type() == RTE_PROC_SECONDARY)
 284                 return 0;
 285
 286         if (port >= rte_eth_dev_count())
 287                 return -1;
 288
 289         printf("# Initialising port %u... ", (unsigned)port);
 290         fflush(stdout);
 291
 292         retval = rte_eth_dev_configure(port, rx_rings, tx_rings, &port_conf);
 293         if (retval < 0)
 294                 return retval;
 295
 296         for (q = 0; q < rx_rings; q ++) {
 297                 retval = rte_eth_rx_queue_setup(port, q, RX_RING_SIZE,
 298                                 SOCKET0, &rx_conf_default,
 299                                 mbuf_pool);
 300                 if (retval < 0)
 301                         return retval;
 302         }
 303
 304         for (q = 0; q < tx_rings; q ++) {
 305                 retval = rte_eth_tx_queue_setup(port, q, RX_RING_SIZE,
 306                                 SOCKET0, &tx_conf_default);
 307                 if (retval < 0)
 308                         return retval;
 309         }
 310
 311         rte_eth_promiscuous_enable(port);
 312
 313         retval  = rte_eth_dev_start(port);
 314         if (retval < 0)
 315                 return retval;
 316
 317         return 0;
 318 }
 319
 320 /* Goes through each of the lcores and calculates what ports should
 321  * be used by that core. Fills in the global lcore_ports[] array.
 322  */
 323 static void
 324 assign_ports_to_cores(void)
 325 {
 326
 327         const unsigned lcores = rte_eal_get_configuration()->lcore_count;
 328         const unsigned port_pairs = num_ports / 2;
 329         const unsigned pairs_per_lcore = port_pairs / lcores;
 330         unsigned extra_pairs = port_pairs % lcores;
 331         unsigned ports_assigned = 0;
 332         unsigned i;
 333
 334         RTE_LCORE_FOREACH(i) {
 335                 lcore_ports[i].start_port = ports_assigned;
 336                 lcore_ports[i].num_ports = pairs_per_lcore * 2;
 337                 if (extra_pairs > 0) {
 338                         lcore_ports[i].num_ports += 2;
 339                         extra_pairs--;
 340                 }
 341                 ports_assigned += lcore_ports[i].num_ports;
 342         }
 343 }
 344
 345 /* Main function used by the processing threads.
 346  * Prints out some configuration details for the thread and then begins
 347  * performing packet RX and TX.
 348  */
 349 static int
 350 lcore_main(void *arg __rte_unused)
 351 {
 352         const unsigned id = rte_lcore_id();
 353         const unsigned start_port = lcore_ports[id].start_port;
 354         const unsigned end_port = start_port + lcore_ports[id].num_ports;
 355         const uint16_t q_id = (uint16_t)proc_id;
 356         unsigned p, i;
 357         char msgbuf[256];
 358         int msgbufpos = 0;
 359
 360         if (start_port == end_port){
 361                 printf("Lcore %u has nothing to do\n", id);
 362                 return 0;
 363         }
 364
 365         /* build up message in msgbuf before printing to decrease likelihood
 366          * of multi-core message interleaving.
 367          */
 368         msgbufpos += rte_snprintf(msgbuf, sizeof(msgbuf) - msgbufpos,
 369                         "Lcore %u using ports ", id);
 370         for (p = start_port; p < end_port; p++){
 371                 msgbufpos += rte_snprintf(msgbuf + msgbufpos, sizeof(msgbuf) - msgbufpos,
 372                                 "%u ", (unsigned)ports[p]);
 373         }
 374         printf("%s\n", msgbuf);
 375         printf("lcore %u using queue %u of each port\n", id, (unsigned)q_id);
 376
 377         /* handle packet I/O from the ports, reading and writing to the
 378          * queue number corresponding to our process number (not lcore id)
 379          */
 380
 381         for (;;) {
 382                 struct rte_mbuf *buf[PKT_BURST];
 383
 384                 for (p = start_port; p < end_port; p++) {
 385                         const uint8_t src = ports[p];
 386                         const uint8_t dst = ports[p ^ 1]; /* 0 <-> 1, 2 <-> 3 etc */
 387                         const uint16_t rx_c = rte_eth_rx_burst(src, q_id, buf, PKT_BURST);
 388                         if (rx_c == 0)
 389                                 continue;
 390                         pstats[src].rx += rx_c;
 391
 392                         const uint16_t tx_c = rte_eth_tx_burst(dst, q_id, buf, rx_c);
 393                         pstats[dst].tx += tx_c;
 394                         if (tx_c != rx_c) {
 395                                 pstats[dst].drop += (rx_c - tx_c);
 396                                 for (i = tx_c; i < rx_c; i++)
 397                                         rte_pktmbuf_free(buf[i]);
 398                         }
 399                 }
 400         }
 401 }
 402
 403 /* Main function.
 404  * Performs initialisation and then calls the lcore_main on each core
 405  * to do the packet-processing work.
 406  */
 407 int
 408 main(int argc, char **argv)
 409 {
 410         static const char *_SMP_MBUF_POOL = "SMP_MBUF_POOL";
 411         int ret;
 412         unsigned i;
 413         enum rte_proc_type_t proc_type;
 414         struct rte_mempool *mp;
 415
 416         /* set up signal handlers to print stats on exit */
 417         signal(SIGINT, print_stats);
 418         signal(SIGTERM, print_stats);
 419
 420         /* initialise the EAL for all */
 421         ret = rte_eal_init(argc, argv);
 422         if (ret < 0)
 423                 rte_exit(EXIT_FAILURE, "Cannot init EAL\n");
 424         argc -= ret;
 425         argv += ret;
 426
 427         /* probe to determine the NIC devices available */
 428         proc_type = rte_eal_process_type();
 429 #ifdef RTE_LIBRTE_IGB_PMD
 430         if (rte_igb_pmd_init() < 0)
 431                 rte_exit(EXIT_FAILURE, "Cannot init igb pmd\n");
 432 #endif
 433 #ifdef RTE_LIBRTE_IXGBE_PMD
 434         if (rte_ixgbe_pmd_init() < 0)
 435                 rte_exit(EXIT_FAILURE, "Cannot init ixgbe pmd\n");
 436 #endif
 437         if (rte_eal_pci_probe() < 0)
 438                 rte_exit(EXIT_FAILURE, "Cannot probe PCI\n");
 439         if (rte_eth_dev_count() == 0)
 440                 rte_exit(EXIT_FAILURE, "No Ethernet ports - bye\n");
 441
 442         /* parse application arguments (those after the EAL ones) */
 443         smp_parse_args(argc, argv);
 444
 445         mp = (proc_type == RTE_PROC_SECONDARY) ?
 446                         rte_mempool_lookup(_SMP_MBUF_POOL) :
 447                         rte_mempool_create(_SMP_MBUF_POOL, NB_MBUFS, MBUF_SIZE,
 448                                         MBUF_CACHE_SIZE, sizeof(struct rte_pktmbuf_pool_private),
 449                                         rte_pktmbuf_pool_init, NULL,
 450                                         rte_pktmbuf_init, NULL,
 451                                         SOCKET0, 0);
 452         if (mp == NULL)
 453                 rte_exit(EXIT_FAILURE, "Cannot get memory pool for buffers\n");
 454
 455         if (num_ports & 1)
 456                 rte_exit(EXIT_FAILURE, "Application must use an even number of ports\n");
 457         for(i = 0; i < num_ports; i++){
 458                 if(proc_type == RTE_PROC_PRIMARY)
 459                         if (smp_port_init(ports[i], mp, (uint16_t)num_procs) < 0)
 460                                 rte_exit(EXIT_FAILURE, "Error initialising ports\n");
 461                 report_link_status(ports[i]);
 462         }
 463
 464         assign_ports_to_cores();
 465
 466         RTE_LOG(INFO, APP, "Finished Process Init.\n");
 467
 468         rte_eal_mp_remote_launch(lcore_main, NULL, CALL_MASTER);
 469
 470         return 0;
 471 }