1 /* SPDX-License-Identifier: BSD-3-Clause 2 * Copyright 2020 Mellanox Technologies, Ltd 3 */ 4 5 #include <stdio.h> 6 #include <stdlib.h> 7 #include <string.h> 8 #include <stdint.h> 9 #include <stdbool.h> 10 #include <stdarg.h> 11 #include <ctype.h> 12 #include <errno.h> 13 #include <getopt.h> 14 #include <signal.h> 15 16 #include <rte_eal.h> 17 #include <rte_common.h> 18 #include <rte_malloc.h> 19 #include <rte_mempool.h> 20 #include <rte_mbuf.h> 21 #include <rte_cycles.h> 22 #include <rte_regexdev.h> 23 24 #define MAX_FILE_NAME 255 25 #define MBUF_CACHE_SIZE 256 26 #define MBUF_SIZE (1 << 8) 27 #define START_BURST_SIZE 32u 28 29 enum app_args { 30 ARG_HELP, 31 ARG_RULES_FILE_NAME, 32 ARG_DATA_FILE_NAME, 33 ARG_NUM_OF_JOBS, 34 ARG_PERF_MODE, 35 ARG_NUM_OF_ITERATIONS, 36 ARG_NUM_OF_QPS, 37 ARG_NUM_OF_LCORES, 38 ARG_NUM_OF_MBUF_SEGS, 39 }; 40 41 struct job_ctx { 42 struct rte_mbuf *mbuf; 43 }; 44 45 struct qp_params { 46 uint32_t total_enqueue; 47 uint32_t total_dequeue; 48 uint32_t total_matches; 49 struct rte_regex_ops **ops; 50 struct job_ctx *jobs_ctx; 51 char *buf; 52 uint64_t start; 53 uint64_t cycles; 54 }; 55 56 struct qps_per_lcore { 57 unsigned int lcore_id; 58 int socket; 59 uint16_t qp_id_base; 60 uint16_t nb_qps; 61 }; 62 63 struct regex_conf { 64 uint32_t nb_jobs; 65 bool perf_mode; 66 uint32_t nb_iterations; 67 char *data_file; 68 uint8_t nb_max_matches; 69 uint32_t nb_qps; 70 uint16_t qp_id_base; 71 char *data_buf; 72 long data_len; 73 long job_len; 74 uint32_t nb_segs; 75 }; 76 77 static void 78 usage(const char *prog_name) 79 { 80 printf("%s [EAL options] --\n" 81 " --rules NAME: precompiled rules file\n" 82 " --data NAME: data file to use\n" 83 " --nb_jobs: number of jobs to use\n" 84 " --perf N: only outputs the performance data\n" 85 " --nb_iter N: number of iteration to run\n" 86 " --nb_qps N: number of queues to use\n" 87 " --nb_lcores N: number of lcores to use\n" 88 " --nb_segs N: number of mbuf segments\n", 89 prog_name); 90 } 91 92 static void 93 args_parse(int argc, char **argv, char *rules_file, char *data_file, 94 uint32_t *nb_jobs, bool *perf_mode, uint32_t *nb_iterations, 95 uint32_t *nb_qps, uint32_t *nb_lcores, uint32_t *nb_segs) 96 { 97 char **argvopt; 98 int opt; 99 int opt_idx; 100 size_t len; 101 static struct option lgopts[] = { 102 { "help", 0, 0, ARG_HELP}, 103 /* Rules database file to load. */ 104 { "rules", 1, 0, ARG_RULES_FILE_NAME}, 105 /* Data file to load. */ 106 { "data", 1, 0, ARG_DATA_FILE_NAME}, 107 /* Number of jobs to create. */ 108 { "nb_jobs", 1, 0, ARG_NUM_OF_JOBS}, 109 /* Perf test only */ 110 { "perf", 0, 0, ARG_PERF_MODE}, 111 /* Number of iterations to run with perf test */ 112 { "nb_iter", 1, 0, ARG_NUM_OF_ITERATIONS}, 113 /* Number of QPs. */ 114 { "nb_qps", 1, 0, ARG_NUM_OF_QPS}, 115 /* Number of lcores. */ 116 { "nb_lcores", 1, 0, ARG_NUM_OF_LCORES}, 117 /* Number of mbuf segments. */ 118 { "nb_segs", 1, 0, ARG_NUM_OF_MBUF_SEGS}, 119 /* End of options */ 120 { 0, 0, 0, 0 } 121 }; 122 123 argvopt = argv; 124 while ((opt = getopt_long(argc, argvopt, "", 125 lgopts, &opt_idx)) != EOF) { 126 switch (opt) { 127 case ARG_RULES_FILE_NAME: 128 len = strnlen(optarg, MAX_FILE_NAME - 1); 129 if (len == MAX_FILE_NAME) 130 rte_exit(EXIT_FAILURE, 131 "Rule file name to long max %d\n", 132 MAX_FILE_NAME - 1); 133 strncpy(rules_file, optarg, MAX_FILE_NAME - 1); 134 break; 135 case ARG_DATA_FILE_NAME: 136 len = strnlen(optarg, MAX_FILE_NAME - 1); 137 if (len == MAX_FILE_NAME) 138 rte_exit(EXIT_FAILURE, 139 "Data file name to long max %d\n", 140 MAX_FILE_NAME - 1); 141 strncpy(data_file, optarg, MAX_FILE_NAME - 1); 142 break; 143 case ARG_NUM_OF_JOBS: 144 *nb_jobs = atoi(optarg); 145 break; 146 case ARG_PERF_MODE: 147 *perf_mode = true; 148 break; 149 case ARG_NUM_OF_ITERATIONS: 150 *nb_iterations = atoi(optarg); 151 break; 152 case ARG_NUM_OF_QPS: 153 *nb_qps = atoi(optarg); 154 break; 155 case ARG_NUM_OF_LCORES: 156 *nb_lcores = atoi(optarg); 157 break; 158 case ARG_NUM_OF_MBUF_SEGS: 159 *nb_segs = atoi(optarg); 160 break; 161 case ARG_HELP: 162 usage(argv[0]); 163 break; 164 default: 165 usage(argv[0]); 166 rte_exit(EXIT_FAILURE, "Invalid option: %s\n", argv[optind]); 167 break; 168 } 169 } 170 171 if (!perf_mode) 172 *nb_iterations = 1; 173 } 174 175 static long 176 read_file(char *file, char **buf) 177 { 178 FILE *fp; 179 long buf_len = 0; 180 size_t read_len; 181 int res = 0; 182 183 fp = fopen(file, "r"); 184 if (!fp) 185 return -EIO; 186 if (fseek(fp, 0L, SEEK_END) == 0) { 187 buf_len = ftell(fp); 188 if (buf_len == -1) { 189 res = EIO; 190 goto error; 191 } 192 *buf = rte_malloc(NULL, sizeof(char) * (buf_len + 1), 4096); 193 if (!*buf) { 194 res = ENOMEM; 195 goto error; 196 } 197 if (fseek(fp, 0L, SEEK_SET) != 0) { 198 res = EIO; 199 goto error; 200 } 201 read_len = fread(*buf, sizeof(char), buf_len, fp); 202 if (read_len != (unsigned long)buf_len) { 203 res = EIO; 204 goto error; 205 } 206 } 207 fclose(fp); 208 return buf_len; 209 error: 210 printf("Error, can't open file %s\n, err = %d", file, res); 211 if (fp) 212 fclose(fp); 213 rte_free(*buf); 214 return -res; 215 } 216 217 static int 218 clone_buf(char *data_buf, char **buf, long data_len) 219 { 220 char *dest_buf; 221 dest_buf = 222 rte_malloc(NULL, sizeof(char) * (data_len + 1), 4096); 223 if (!dest_buf) 224 return -ENOMEM; 225 memcpy(dest_buf, data_buf, data_len + 1); 226 *buf = dest_buf; 227 return 0; 228 } 229 230 static int 231 init_port(uint16_t *nb_max_payload, char *rules_file, uint8_t *nb_max_matches, 232 uint32_t nb_qps) 233 { 234 uint16_t id; 235 uint16_t qp_id; 236 uint16_t num_devs; 237 char *rules = NULL; 238 long rules_len; 239 struct rte_regexdev_info info; 240 struct rte_regexdev_config dev_conf = { 241 .nb_queue_pairs = nb_qps, 242 .nb_groups = 1, 243 }; 244 struct rte_regexdev_qp_conf qp_conf = { 245 .nb_desc = 1024, 246 .qp_conf_flags = 0, 247 }; 248 int res = 0; 249 250 num_devs = rte_regexdev_count(); 251 if (num_devs == 0) { 252 printf("Error, no devices detected.\n"); 253 return -EINVAL; 254 } 255 256 rules_len = read_file(rules_file, &rules); 257 if (rules_len < 0) { 258 printf("Error, can't read rules files.\n"); 259 res = -EIO; 260 goto error; 261 } 262 263 for (id = 0; id < num_devs; id++) { 264 res = rte_regexdev_info_get(id, &info); 265 if (res != 0) { 266 printf("Error, can't get device info.\n"); 267 goto error; 268 } 269 printf(":: initializing dev: %d\n", id); 270 *nb_max_matches = info.max_matches; 271 *nb_max_payload = info.max_payload_size; 272 if (info.regexdev_capa & RTE_REGEXDEV_SUPP_MATCH_AS_END_F) 273 dev_conf.dev_cfg_flags |= 274 RTE_REGEXDEV_CFG_MATCH_AS_END_F; 275 dev_conf.nb_max_matches = info.max_matches; 276 dev_conf.nb_rules_per_group = info.max_rules_per_group; 277 dev_conf.rule_db_len = rules_len; 278 dev_conf.rule_db = rules; 279 res = rte_regexdev_configure(id, &dev_conf); 280 if (res < 0) { 281 printf("Error, can't configure device %d.\n", id); 282 goto error; 283 } 284 if (info.regexdev_capa & RTE_REGEXDEV_CAPA_QUEUE_PAIR_OOS_F) 285 qp_conf.qp_conf_flags |= 286 RTE_REGEX_QUEUE_PAIR_CFG_OOS_F; 287 for (qp_id = 0; qp_id < nb_qps; qp_id++) { 288 res = rte_regexdev_queue_pair_setup(id, qp_id, 289 &qp_conf); 290 if (res < 0) { 291 printf("Error, can't setup queue pair %u for " 292 "device %d.\n", qp_id, id); 293 goto error; 294 } 295 } 296 printf(":: initializing device: %d done\n", id); 297 } 298 rte_free(rules); 299 return 0; 300 error: 301 rte_free(rules); 302 return res; 303 } 304 305 static void 306 extbuf_free_cb(void *addr __rte_unused, void *fcb_opaque __rte_unused) 307 { 308 } 309 310 static inline struct rte_mbuf * 311 regex_create_segmented_mbuf(struct rte_mempool *mbuf_pool, int pkt_len, 312 int nb_segs, void *buf) { 313 314 struct rte_mbuf *m = NULL, *mbuf = NULL; 315 uint8_t *dst; 316 char *src = buf; 317 int data_len = 0; 318 int i, size; 319 int t_len; 320 321 if (pkt_len < 1) { 322 printf("Packet size must be 1 or more (is %d)\n", pkt_len); 323 return NULL; 324 } 325 326 if (nb_segs < 1) { 327 printf("Number of segments must be 1 or more (is %d)\n", 328 nb_segs); 329 return NULL; 330 } 331 332 t_len = pkt_len >= nb_segs ? (pkt_len / nb_segs + 333 !!(pkt_len % nb_segs)) : 1; 334 size = pkt_len; 335 336 /* Create chained mbuf_src and fill it with buf data */ 337 for (i = 0; size > 0; i++) { 338 339 m = rte_pktmbuf_alloc(mbuf_pool); 340 if (i == 0) 341 mbuf = m; 342 343 if (m == NULL) { 344 printf("Cannot create segment for source mbuf"); 345 goto fail; 346 } 347 348 data_len = size > t_len ? t_len : size; 349 memset(rte_pktmbuf_mtod(m, uint8_t *), 0, 350 rte_pktmbuf_tailroom(m)); 351 memcpy(rte_pktmbuf_mtod(m, uint8_t *), src, data_len); 352 dst = (uint8_t *)rte_pktmbuf_append(m, data_len); 353 if (dst == NULL) { 354 printf("Cannot append %d bytes to the mbuf\n", 355 data_len); 356 goto fail; 357 } 358 359 if (mbuf != m) 360 rte_pktmbuf_chain(mbuf, m); 361 src += data_len; 362 size -= data_len; 363 364 } 365 return mbuf; 366 367 fail: 368 rte_pktmbuf_free(mbuf); 369 return NULL; 370 } 371 372 static int 373 run_regex(void *args) 374 { 375 struct regex_conf *rgxc = args; 376 uint32_t nb_jobs = rgxc->nb_jobs; 377 uint32_t nb_segs = rgxc->nb_segs; 378 uint32_t nb_iterations = rgxc->nb_iterations; 379 uint8_t nb_max_matches = rgxc->nb_max_matches; 380 uint32_t nb_qps = rgxc->nb_qps; 381 uint16_t qp_id_base = rgxc->qp_id_base; 382 char *data_buf = rgxc->data_buf; 383 long data_len = rgxc->data_len; 384 long job_len = rgxc->job_len; 385 386 char *buf = NULL; 387 uint32_t actual_jobs = 0; 388 uint32_t i; 389 uint16_t qp_id; 390 uint16_t dev_id = 0; 391 uint8_t nb_matches; 392 struct rte_regexdev_match *match; 393 long pos; 394 unsigned long d_ind = 0; 395 struct rte_mbuf_ext_shared_info shinfo; 396 int res = 0; 397 long double time; 398 struct rte_mempool *mbuf_mp; 399 struct qp_params *qp; 400 struct qp_params *qps = NULL; 401 bool update; 402 uint16_t qps_used = 0; 403 char mbuf_pool[16]; 404 405 shinfo.free_cb = extbuf_free_cb; 406 snprintf(mbuf_pool, 407 sizeof(mbuf_pool), 408 "mbuf_pool_%2u", qp_id_base); 409 mbuf_mp = rte_pktmbuf_pool_create(mbuf_pool, 410 rte_align32pow2(nb_jobs * nb_qps * nb_segs), 411 0, 0, (nb_segs == 1) ? MBUF_SIZE : 412 (rte_align32pow2(job_len) / nb_segs + 413 RTE_PKTMBUF_HEADROOM), 414 rte_socket_id()); 415 if (mbuf_mp == NULL) { 416 printf("Error, can't create memory pool\n"); 417 return -ENOMEM; 418 } 419 420 qps = rte_malloc(NULL, sizeof(*qps) * nb_qps, 0); 421 if (!qps) { 422 printf("Error, can't allocate memory for QPs\n"); 423 res = -ENOMEM; 424 goto end; 425 } 426 427 for (qp_id = 0; qp_id < nb_qps; qp_id++) { 428 struct rte_regex_ops **ops; 429 struct job_ctx *jobs_ctx; 430 431 qps_used++; 432 qp = &qps[qp_id]; 433 qp->jobs_ctx = NULL; 434 qp->buf = NULL; 435 qp->ops = ops = rte_malloc(NULL, sizeof(*ops) * nb_jobs, 0); 436 if (!ops) { 437 printf("Error, can't allocate memory for ops.\n"); 438 res = -ENOMEM; 439 goto end; 440 } 441 442 qp->jobs_ctx = jobs_ctx = 443 rte_malloc(NULL, sizeof(*jobs_ctx) * nb_jobs, 0); 444 if (!jobs_ctx) { 445 printf("Error, can't allocate memory for jobs_ctx.\n"); 446 res = -ENOMEM; 447 goto end; 448 } 449 450 if (clone_buf(data_buf, &buf, data_len)) { 451 printf("Error, can't clone buf.\n"); 452 res = -EXIT_FAILURE; 453 goto end; 454 } 455 456 /* Assign each mbuf with the data to handle. */ 457 actual_jobs = 0; 458 pos = 0; 459 /* Allocate the jobs and assign each job with an mbuf. */ 460 for (i = 0; (pos < data_len) && (i < nb_jobs) ; i++) { 461 long act_job_len = RTE_MIN(job_len, data_len - pos); 462 463 ops[i] = rte_malloc(NULL, sizeof(*ops[0]) + 464 nb_max_matches * 465 sizeof(struct rte_regexdev_match), 0); 466 if (!ops[i]) { 467 printf("Error, can't allocate " 468 "memory for op.\n"); 469 res = -ENOMEM; 470 goto end; 471 } 472 if (nb_segs > 1) { 473 ops[i]->mbuf = regex_create_segmented_mbuf 474 (mbuf_mp, act_job_len, 475 nb_segs, &buf[pos]); 476 } else { 477 ops[i]->mbuf = rte_pktmbuf_alloc(mbuf_mp); 478 if (ops[i]->mbuf) { 479 rte_pktmbuf_attach_extbuf(ops[i]->mbuf, 480 &buf[pos], 0, act_job_len, &shinfo); 481 ops[i]->mbuf->data_len = job_len; 482 ops[i]->mbuf->pkt_len = act_job_len; 483 } 484 } 485 if (!ops[i]->mbuf) { 486 printf("Error, can't add mbuf.\n"); 487 res = -ENOMEM; 488 goto end; 489 } 490 491 jobs_ctx[i].mbuf = ops[i]->mbuf; 492 ops[i]->user_id = i; 493 ops[i]->group_id0 = 1; 494 pos += act_job_len; 495 actual_jobs++; 496 } 497 498 qp->buf = buf; 499 qp->total_matches = 0; 500 qp->start = 0; 501 qp->cycles = 0; 502 } 503 504 for (i = 0; i < nb_iterations; i++) { 505 for (qp_id = 0; qp_id < nb_qps; qp_id++) { 506 qp = &qps[qp_id]; 507 qp->total_enqueue = 0; 508 qp->total_dequeue = 0; 509 } 510 do { 511 update = false; 512 for (qp_id = 0; qp_id < nb_qps; qp_id++) { 513 qp = &qps[qp_id]; 514 if (qp->total_dequeue < actual_jobs) { 515 qp->start = rte_rdtsc_precise(); 516 struct rte_regex_ops ** 517 cur_ops_to_enqueue = qp->ops + 518 qp->total_enqueue; 519 520 if (actual_jobs - qp->total_enqueue) 521 qp->total_enqueue += 522 rte_regexdev_enqueue_burst 523 (dev_id, 524 qp_id_base + qp_id, 525 cur_ops_to_enqueue, 526 actual_jobs - 527 qp->total_enqueue); 528 } 529 } 530 for (qp_id = 0; qp_id < nb_qps; qp_id++) { 531 qp = &qps[qp_id]; 532 if (qp->total_dequeue < actual_jobs) { 533 struct rte_regex_ops ** 534 cur_ops_to_dequeue = qp->ops + 535 qp->total_dequeue; 536 537 qp->total_dequeue += 538 rte_regexdev_dequeue_burst 539 (dev_id, 540 qp_id_base + qp_id, 541 cur_ops_to_dequeue, 542 qp->total_enqueue - 543 qp->total_dequeue); 544 qp->cycles += 545 (rte_rdtsc_precise() - qp->start); 546 update = true; 547 } 548 } 549 } while (update); 550 } 551 for (qp_id = 0; qp_id < nb_qps; qp_id++) { 552 qp = &qps[qp_id]; 553 time = (long double)qp->cycles / rte_get_timer_hz(); 554 printf("Core=%u QP=%u Job=%ld Bytes Time=%Lf sec Perf=%Lf " 555 "Gbps\n", rte_lcore_id(), qp_id + qp_id_base, 556 job_len, time, 557 (((double)actual_jobs * job_len * nb_iterations * 8) 558 / time) / 1000000000.0); 559 } 560 561 if (rgxc->perf_mode) 562 goto end; 563 for (qp_id = 0; qp_id < nb_qps; qp_id++) { 564 printf("\n############ Core=%u QP=%u ############\n", 565 rte_lcore_id(), qp_id + qp_id_base); 566 qp = &qps[qp_id]; 567 /* Log results per job. */ 568 for (d_ind = 0; d_ind < qp->total_dequeue; d_ind++) { 569 nb_matches = qp->ops[d_ind % actual_jobs]->nb_matches; 570 printf("Job id %"PRIu64" number of matches = %d\n", 571 qp->ops[d_ind]->user_id, nb_matches); 572 qp->total_matches += nb_matches; 573 match = qp->ops[d_ind % actual_jobs]->matches; 574 for (i = 0; i < nb_matches; i++) { 575 printf("match %d, rule = %d, " 576 "start = %d,len = %d\n", 577 i, match->rule_id, match->start_offset, 578 match->len); 579 match++; 580 } 581 } 582 printf("Total matches = %d\n", qp->total_matches); 583 printf("All Matches:\n"); 584 /* Log absolute results. */ 585 for (d_ind = 0; d_ind < qp->total_dequeue; d_ind++) { 586 nb_matches = qp->ops[d_ind % actual_jobs]->nb_matches; 587 qp->total_matches += nb_matches; 588 match = qp->ops[d_ind % actual_jobs]->matches; 589 for (i = 0; i < nb_matches; i++) { 590 printf("start = %ld, len = %d, rule = %d\n", 591 match->start_offset + 592 d_ind * job_len, 593 match->len, match->rule_id); 594 match++; 595 } 596 } 597 } 598 end: 599 for (qp_id = 0; qp_id < qps_used; qp_id++) { 600 qp = &qps[qp_id]; 601 for (i = 0; i < actual_jobs && qp->ops; i++) 602 rte_free(qp->ops[i]); 603 rte_free(qp->ops); 604 qp->ops = NULL; 605 for (i = 0; i < actual_jobs && qp->jobs_ctx; i++) 606 rte_pktmbuf_free(qp->jobs_ctx[i].mbuf); 607 rte_free(qp->jobs_ctx); 608 qp->jobs_ctx = NULL; 609 rte_free(qp->buf); 610 qp->buf = NULL; 611 } 612 rte_mempool_free(mbuf_mp); 613 rte_free(qps); 614 return res; 615 } 616 617 static int 618 distribute_qps_to_lcores(uint32_t nb_cores, uint32_t nb_qps, 619 struct qps_per_lcore **qpl) 620 { 621 int socket; 622 unsigned lcore_id; 623 uint32_t i; 624 uint16_t min_qp_id; 625 uint16_t max_qp_id; 626 struct qps_per_lcore *qps_per_lcore; 627 uint32_t detected_lcores; 628 629 if (nb_qps < nb_cores) { 630 nb_cores = nb_qps; 631 printf("Reducing number of cores to number of QPs (%u)\n", 632 nb_cores); 633 } 634 /* Allocate qps_per_lcore array */ 635 qps_per_lcore = 636 rte_malloc(NULL, sizeof(*qps_per_lcore) * nb_cores, 0); 637 if (!qps_per_lcore) 638 rte_exit(EXIT_FAILURE, "Failed to create qps_per_lcore array\n"); 639 *qpl = qps_per_lcore; 640 detected_lcores = 0; 641 min_qp_id = 0; 642 643 RTE_LCORE_FOREACH_WORKER(lcore_id) { 644 if (detected_lcores >= nb_cores) 645 break; 646 qps_per_lcore[detected_lcores].lcore_id = lcore_id; 647 socket = rte_lcore_to_socket_id(lcore_id); 648 if (socket == SOCKET_ID_ANY) 649 socket = 0; 650 qps_per_lcore[detected_lcores].socket = socket; 651 qps_per_lcore[detected_lcores].qp_id_base = min_qp_id; 652 max_qp_id = min_qp_id + nb_qps / nb_cores - 1; 653 if (nb_qps % nb_cores > detected_lcores) 654 max_qp_id++; 655 qps_per_lcore[detected_lcores].nb_qps = max_qp_id - 656 min_qp_id + 1; 657 min_qp_id = max_qp_id + 1; 658 detected_lcores++; 659 } 660 if (detected_lcores != nb_cores) 661 return -1; 662 663 for (i = 0; i < detected_lcores; i++) { 664 printf("===> Core %d: allocated queues: ", 665 qps_per_lcore[i].lcore_id); 666 min_qp_id = qps_per_lcore[i].qp_id_base; 667 max_qp_id = 668 qps_per_lcore[i].qp_id_base + qps_per_lcore[i].nb_qps; 669 while (min_qp_id < max_qp_id) { 670 printf("%u ", min_qp_id); 671 min_qp_id++; 672 } 673 printf("\n"); 674 } 675 return 0; 676 } 677 678 int 679 main(int argc, char **argv) 680 { 681 char rules_file[MAX_FILE_NAME]; 682 char data_file[MAX_FILE_NAME]; 683 uint32_t nb_jobs = 0; 684 bool perf_mode = 0; 685 uint32_t nb_iterations = 0; 686 int ret; 687 uint16_t nb_max_payload = 0; 688 uint8_t nb_max_matches = 0; 689 uint32_t nb_qps = 1; 690 char *data_buf; 691 long data_len; 692 long job_len; 693 uint32_t nb_lcores = 1, nb_segs = 1; 694 struct regex_conf *rgxc; 695 uint32_t i; 696 struct qps_per_lcore *qps_per_lcore; 697 698 /* Init EAL. */ 699 ret = rte_eal_init(argc, argv); 700 if (ret < 0) 701 rte_exit(EXIT_FAILURE, "EAL init failed\n"); 702 argc -= ret; 703 argv += ret; 704 if (argc > 1) 705 args_parse(argc, argv, rules_file, data_file, &nb_jobs, 706 &perf_mode, &nb_iterations, &nb_qps, 707 &nb_lcores, &nb_segs); 708 709 if (nb_qps == 0) 710 rte_exit(EXIT_FAILURE, "Number of QPs must be greater than 0\n"); 711 if (nb_lcores == 0) 712 rte_exit(EXIT_FAILURE, "Number of lcores must be greater than 0\n"); 713 if (distribute_qps_to_lcores(nb_lcores, nb_qps, &qps_per_lcore) < 0) 714 rte_exit(EXIT_FAILURE, "Failed to distribute queues to lcores!\n"); 715 ret = init_port(&nb_max_payload, rules_file, 716 &nb_max_matches, nb_qps); 717 if (ret < 0) 718 rte_exit(EXIT_FAILURE, "init port failed\n"); 719 720 data_len = read_file(data_file, &data_buf); 721 if (data_len <= 0) 722 rte_exit(EXIT_FAILURE, "Error, can't read file, or file is empty.\n"); 723 724 job_len = data_len / nb_jobs; 725 if (job_len == 0) 726 rte_exit(EXIT_FAILURE, "Error, To many jobs, for the given input.\n"); 727 728 if (job_len > nb_max_payload) 729 rte_exit(EXIT_FAILURE, "Error, not enough jobs to cover input.\n"); 730 731 rgxc = rte_malloc(NULL, sizeof(*rgxc) * nb_lcores, 0); 732 if (!rgxc) 733 rte_exit(EXIT_FAILURE, "Failed to create Regex Conf\n"); 734 for (i = 0; i < nb_lcores; i++) { 735 rgxc[i] = (struct regex_conf){ 736 .nb_jobs = nb_jobs, 737 .nb_segs = nb_segs, 738 .perf_mode = perf_mode, 739 .nb_iterations = nb_iterations, 740 .nb_max_matches = nb_max_matches, 741 .nb_qps = qps_per_lcore[i].nb_qps, 742 .qp_id_base = qps_per_lcore[i].qp_id_base, 743 .data_buf = data_buf, 744 .data_len = data_len, 745 .job_len = job_len, 746 }; 747 rte_eal_remote_launch(run_regex, &rgxc[i], 748 qps_per_lcore[i].lcore_id); 749 } 750 rte_eal_mp_wait_lcore(); 751 rte_free(data_buf); 752 rte_free(rgxc); 753 rte_free(qps_per_lcore); 754 return EXIT_SUCCESS; 755 } 756