app/test-eventdev/evt_options.c

   1 /*
   2  *   BSD LICENSE
   3  *
   4  *   Copyright (C) Cavium, Inc 2017.
   5  *
   6  *   Redistribution and use in source and binary forms, with or without
   7  *   modification, are permitted provided that the following conditions
   8  *   are met:
   9  *
  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
  15  *       distribution.
  16  *     * Neither the name of Cavium, Inc 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.
  19  *
  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.
  31  */
  32
  33 #include <stdio.h>
  34 #include <string.h>
  35 #include <inttypes.h>
  36 #include <getopt.h>
  37
  38 #include <rte_common.h>
  39 #include <rte_eventdev.h>
  40 #include <rte_lcore.h>
  41
  42 #include "evt_options.h"
  43 #include "evt_test.h"
  44 #include "parser.h"
  45
  46 void
  47 evt_options_default(struct evt_options *opt)
  48 {
  49         memset(opt, 0, sizeof(*opt));
  50         opt->verbose_level = 1; /* Enable minimal prints */
  51         opt->dev_id = 0;
  52         strncpy(opt->test_name, "order_queue", EVT_TEST_NAME_MAX_LEN);
  53         opt->nb_flows = 1024;
  54         opt->socket_id = SOCKET_ID_ANY;
  55         opt->pool_sz = 16 * 1024;
  56         opt->wkr_deq_dep = 16;
  57         opt->nb_pkts = (1ULL << 26); /* do ~64M packets */
  58 }
  59
  60 typedef int (*option_parser_t)(struct evt_options *opt,
  61                 const char *arg);
  62
  63 struct long_opt_parser {
  64         const char *lgopt_name;
  65         option_parser_t parser_fn;
  66 };
  67
  68 static int
  69 evt_parse_nb_flows(struct evt_options *opt, const char *arg)
  70 {
  71         int ret;
  72
  73         ret = parser_read_uint32(&(opt->nb_flows), arg);
  74
  75         return ret;
  76 }
  77
  78 static int
  79 evt_parse_dev_id(struct evt_options *opt, const char *arg)
  80 {
  81         int ret;
  82
  83         ret = parser_read_uint8(&(opt->dev_id), arg);
  84
  85         return ret;
  86 }
  87
  88 static int
  89 evt_parse_verbose(struct evt_options *opt, const char *arg __rte_unused)
  90 {
  91         opt->verbose_level = atoi(arg);
  92         return 0;
  93 }
  94
  95 static int
  96 evt_parse_fwd_latency(struct evt_options *opt, const char *arg __rte_unused)
  97 {
  98         opt->fwd_latency = 1;
  99         return 0;
 100 }
 101
 102 static int
 103 evt_parse_queue_priority(struct evt_options *opt, const char *arg __rte_unused)
 104 {
 105         opt->q_priority = 1;
 106         return 0;
 107 }
 108
 109 static int
 110 evt_parse_test_name(struct evt_options *opt, const char *arg)
 111 {
 112         snprintf(opt->test_name, EVT_TEST_NAME_MAX_LEN, "%s", arg);
 113         return 0;
 114 }
 115
 116 static int
 117 evt_parse_slcore(struct evt_options *opt, const char *arg)
 118 {
 119         opt->slcore = atoi(arg);
 120         return 0;
 121 }
 122
 123 static int
 124 evt_parse_socket_id(struct evt_options *opt, const char *arg)
 125 {
 126         opt->socket_id = atoi(arg);
 127         return 0;
 128 }
 129
 130 static int
 131 evt_parse_wkr_deq_dep(struct evt_options *opt, const char *arg)
 132 {
 133         int ret;
 134
 135         ret = parser_read_uint16(&(opt->wkr_deq_dep), arg);
 136         return ret;
 137 }
 138
 139 static int
 140 evt_parse_nb_pkts(struct evt_options *opt, const char *arg)
 141 {
 142         int ret;
 143
 144         ret = parser_read_uint64(&(opt->nb_pkts), arg);
 145
 146         return ret;
 147 }
 148
 149 static int
 150 evt_parse_pool_sz(struct evt_options *opt, const char *arg)
 151 {
 152         opt->pool_sz = atoi(arg);
 153
 154         return 0;
 155 }
 156
 157 static int
 158 evt_parse_plcores(struct evt_options *opt, const char *corelist)
 159 {
 160         int ret;
 161
 162         ret = parse_lcores_list(opt->plcores, corelist);
 163         if (ret == -E2BIG)
 164                 evt_err("duplicate lcores in plcores");
 165
 166         return ret;
 167 }
 168
 169 static int
 170 evt_parse_work_lcores(struct evt_options *opt, const char *corelist)
 171 {
 172         int ret;
 173
 174         ret = parse_lcores_list(opt->wlcores, corelist);
 175         if (ret == -E2BIG)
 176                 evt_err("duplicate lcores in wlcores");
 177
 178         return ret;
 179 }
 180
 181 static void
 182 usage(char *program)
 183 {
 184         printf("usage : %s [EAL options] -- [application options]\n", program);
 185         printf("application options:\n");
 186         printf("\t--verbose          : verbose level\n"
 187                 "\t--dev              : device id of the event device\n"
 188                 "\t--test             : name of the test application to run\n"
 189                 "\t--socket_id        : socket_id of application resources\n"
 190                 "\t--pool_sz          : pool size of the mempool\n"
 191                 "\t--slcore           : lcore id of the scheduler\n"
 192                 "\t--plcores          : list of lcore ids for producers\n"
 193                 "\t--wlcores          : list of lcore ids for workers\n"
 194                 "\t--stlist           : list of scheduled types of the stages\n"
 195                 "\t--nb_flows         : number of flows to produce\n"
 196                 "\t--nb_pkts          : number of packets to produce\n"
 197                 "\t--worker_deq_depth : dequeue depth of the worker\n"
 198                 "\t--fwd_latency      : perform fwd_latency measurement\n"
 199                 "\t--queue_priority   : enable queue priority\n"
 200                 );
 201         printf("available tests:\n");
 202         evt_test_dump_names();
 203 }
 204
 205 static int
 206 evt_parse_sched_type_list(struct evt_options *opt, const char *arg)
 207 {
 208         char c;
 209         int i = 0, j = -1;
 210
 211         for (i = 0; i < EVT_MAX_STAGES; i++)
 212                 opt->sched_type_list[i] = (uint8_t)-1;
 213
 214         i = 0;
 215
 216         do {
 217                 c = arg[++j];
 218
 219                 switch (c) {
 220                 case 'o':
 221                 case 'O':
 222                         opt->sched_type_list[i++] = RTE_SCHED_TYPE_ORDERED;
 223                         break;
 224                 case 'a':
 225                 case 'A':
 226                         opt->sched_type_list[i++] = RTE_SCHED_TYPE_ATOMIC;
 227                         break;
 228                 case 'p':
 229                 case 'P':
 230                         opt->sched_type_list[i++] = RTE_SCHED_TYPE_PARALLEL;
 231                         break;
 232                 case ',':
 233                         break;
 234                 default:
 235                         if (c != '\0') {
 236                                 evt_err("invalid sched_type %c", c);
 237                                 return -EINVAL;
 238                         }
 239                 }
 240         } while (c != '\0');
 241
 242         opt->nb_stages = i;
 243         return 0;
 244 }
 245
 246 static struct option lgopts[] = {
 247         { EVT_NB_FLOWS,         1, 0, 0 },
 248         { EVT_DEVICE,           1, 0, 0 },
 249         { EVT_VERBOSE,          1, 0, 0 },
 250         { EVT_TEST,             1, 0, 0 },
 251         { EVT_PROD_LCORES,      1, 0, 0 },
 252         { EVT_WORK_LCORES,      1, 0, 0 },
 253         { EVT_SOCKET_ID,        1, 0, 0 },
 254         { EVT_POOL_SZ,          1, 0, 0 },
 255         { EVT_NB_PKTS,          1, 0, 0 },
 256         { EVT_WKR_DEQ_DEP,      1, 0, 0 },
 257         { EVT_SCHED_LCORE,      1, 0, 0 },
 258         { EVT_SCHED_TYPE_LIST,  1, 0, 0 },
 259         { EVT_FWD_LATENCY,      0, 0, 0 },
 260         { EVT_QUEUE_PRIORITY,   0, 0, 0 },
 261         { EVT_HELP,             0, 0, 0 },
 262         { NULL,                 0, 0, 0 }
 263 };
 264
 265 static int
 266 evt_opts_parse_long(int opt_idx, struct evt_options *opt)
 267 {
 268         unsigned int i;
 269
 270         struct long_opt_parser parsermap[] = {
 271                 { EVT_NB_FLOWS, evt_parse_nb_flows},
 272                 { EVT_DEVICE, evt_parse_dev_id},
 273                 { EVT_VERBOSE, evt_parse_verbose},
 274                 { EVT_TEST, evt_parse_test_name},
 275                 { EVT_PROD_LCORES, evt_parse_plcores},
 276                 { EVT_WORK_LCORES, evt_parse_work_lcores},
 277                 { EVT_SOCKET_ID, evt_parse_socket_id},
 278                 { EVT_POOL_SZ, evt_parse_pool_sz},
 279                 { EVT_NB_PKTS, evt_parse_nb_pkts},
 280                 { EVT_WKR_DEQ_DEP, evt_parse_wkr_deq_dep},
 281                 { EVT_SCHED_LCORE, evt_parse_slcore},
 282                 { EVT_SCHED_TYPE_LIST, evt_parse_sched_type_list},
 283                 { EVT_FWD_LATENCY, evt_parse_fwd_latency},
 284                 { EVT_QUEUE_PRIORITY, evt_parse_queue_priority},
 285         };
 286
 287         for (i = 0; i < RTE_DIM(parsermap); i++) {
 288                 if (strncmp(lgopts[opt_idx].name, parsermap[i].lgopt_name,
 289                                 strlen(parsermap[i].lgopt_name)) == 0)
 290                         return parsermap[i].parser_fn(opt, optarg);
 291         }
 292
 293         return -EINVAL;
 294 }
 295
 296 int
 297 evt_options_parse(struct evt_options *opt, int argc, char **argv)
 298 {
 299         int opts, retval, opt_idx;
 300
 301         while ((opts = getopt_long(argc, argv, "", lgopts, &opt_idx)) != EOF) {
 302                 switch (opts) {
 303                 case 0: /* long options */
 304                         if (!strcmp(lgopts[opt_idx].name, "help")) {
 305                                 usage(argv[0]);
 306                                 exit(EXIT_SUCCESS);
 307                         }
 308
 309                         retval = evt_opts_parse_long(opt_idx, opt);
 310                         if (retval != 0)
 311                                 return retval;
 312                         break;
 313                 default:
 314                         return -EINVAL;
 315                 }
 316         }
 317         return 0;
 318 }
 319
 320 void
 321 evt_options_dump(struct evt_options *opt)
 322 {
 323         int lcore_id;
 324         struct rte_event_dev_info dev_info;
 325
 326         rte_event_dev_info_get(opt->dev_id, &dev_info);
 327         evt_dump("driver", "%s", dev_info.driver_name);
 328         evt_dump("test", "%s", opt->test_name);
 329         evt_dump("dev", "%d", opt->dev_id);
 330         evt_dump("verbose_level", "%d", opt->verbose_level);
 331         evt_dump("socket_id", "%d", opt->socket_id);
 332         evt_dump("pool_sz", "%d", opt->pool_sz);
 333         evt_dump("master lcore", "%d", rte_get_master_lcore());
 334         evt_dump("nb_pkts", "%"PRIu64, opt->nb_pkts);
 335         evt_dump_begin("available lcores");
 336         RTE_LCORE_FOREACH(lcore_id)
 337                 printf("%d ", lcore_id);
 338         evt_dump_end;
 339         evt_dump_nb_flows(opt);
 340         evt_dump_worker_dequeue_depth(opt);
 341 }