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 long remainder; 386 long act_job_len = 0; 387 bool last_job = false; 388 char *buf = NULL; 389 uint32_t actual_jobs = 0; 390 uint32_t i; 391 uint32_t job_id; 392 uint16_t qp_id; 393 uint16_t dev_id = 0; 394 uint8_t nb_matches; 395 struct rte_regexdev_match *match; 396 long pos; 397 unsigned long d_ind = 0; 398 struct rte_mbuf_ext_shared_info shinfo; 399 int res = 0; 400 long double time; 401 struct rte_mempool *mbuf_mp; 402 struct qp_params *qp; 403 struct qp_params *qps = NULL; 404 bool update; 405 uint16_t qps_used = 0; 406 char mbuf_pool[16]; 407 408 shinfo.free_cb = extbuf_free_cb; 409 snprintf(mbuf_pool, 410 sizeof(mbuf_pool), 411 "mbuf_pool_%2u", qp_id_base); 412 mbuf_mp = rte_pktmbuf_pool_create(mbuf_pool, 413 rte_align32pow2(nb_jobs * nb_qps * nb_segs), 414 0, 0, (nb_segs == 1) ? MBUF_SIZE : 415 (rte_align32pow2(job_len + (data_len % nb_jobs)) / 416 nb_segs + RTE_PKTMBUF_HEADROOM), 417 rte_socket_id()); 418 if (mbuf_mp == NULL) { 419 printf("Error, can't create memory pool\n"); 420 return -ENOMEM; 421 } 422 423 qps = rte_malloc(NULL, sizeof(*qps) * nb_qps, 0); 424 if (!qps) { 425 printf("Error, can't allocate memory for QPs\n"); 426 res = -ENOMEM; 427 goto end; 428 } 429 430 for (qp_id = 0; qp_id < nb_qps; qp_id++) { 431 struct rte_regex_ops **ops; 432 struct job_ctx *jobs_ctx; 433 434 qps_used++; 435 qp = &qps[qp_id]; 436 qp->jobs_ctx = NULL; 437 qp->buf = NULL; 438 qp->ops = ops = rte_malloc(NULL, sizeof(*ops) * nb_jobs, 0); 439 if (!ops) { 440 printf("Error, can't allocate memory for ops.\n"); 441 res = -ENOMEM; 442 goto end; 443 } 444 445 qp->jobs_ctx = jobs_ctx = 446 rte_malloc(NULL, sizeof(*jobs_ctx) * nb_jobs, 0); 447 if (!jobs_ctx) { 448 printf("Error, can't allocate memory for jobs_ctx.\n"); 449 res = -ENOMEM; 450 goto end; 451 } 452 453 if (clone_buf(data_buf, &buf, data_len)) { 454 printf("Error, can't clone buf.\n"); 455 res = -EXIT_FAILURE; 456 goto end; 457 } 458 459 /* Assign each mbuf with the data to handle. */ 460 actual_jobs = 0; 461 pos = 0; 462 remainder = data_len % nb_jobs; 463 464 /* Allocate the jobs and assign each job with an mbuf. */ 465 for (i = 0; (pos < data_len) && (i < nb_jobs) ; i++) { 466 act_job_len = RTE_MIN(job_len, data_len - pos); 467 468 if (i == (nb_jobs - 1)) { 469 last_job = true; 470 act_job_len += remainder; 471 } 472 473 ops[i] = rte_malloc(NULL, sizeof(*ops[0]) + 474 nb_max_matches * 475 sizeof(struct rte_regexdev_match), 0); 476 if (!ops[i]) { 477 printf("Error, can't allocate " 478 "memory for op.\n"); 479 res = -ENOMEM; 480 goto end; 481 } 482 if (nb_segs > 1) { 483 ops[i]->mbuf = regex_create_segmented_mbuf 484 (mbuf_mp, act_job_len, 485 nb_segs, &buf[pos]); 486 } else { 487 ops[i]->mbuf = rte_pktmbuf_alloc(mbuf_mp); 488 if (ops[i]->mbuf) { 489 rte_pktmbuf_attach_extbuf(ops[i]->mbuf, 490 &buf[pos], 0, act_job_len, &shinfo); 491 492 if (!last_job) 493 ops[i]->mbuf->data_len = job_len; 494 else 495 ops[i]->mbuf->data_len = act_job_len; 496 497 ops[i]->mbuf->pkt_len = act_job_len; 498 } 499 } 500 if (!ops[i]->mbuf) { 501 printf("Error, can't add mbuf.\n"); 502 res = -ENOMEM; 503 goto end; 504 } 505 506 jobs_ctx[i].mbuf = ops[i]->mbuf; 507 ops[i]->user_id = i; 508 ops[i]->group_id0 = 1; 509 pos += act_job_len; 510 actual_jobs++; 511 } 512 513 qp->buf = buf; 514 qp->total_matches = 0; 515 qp->start = 0; 516 qp->cycles = 0; 517 } 518 519 for (i = 0; i < nb_iterations; i++) { 520 for (qp_id = 0; qp_id < nb_qps; qp_id++) { 521 qp = &qps[qp_id]; 522 qp->total_enqueue = 0; 523 qp->total_dequeue = 0; 524 /* Re-set user id after dequeue to match data in mbuf. */ 525 for (job_id = 0 ; job_id < nb_jobs; job_id++) 526 qp->ops[job_id]->user_id = job_id; 527 } 528 do { 529 update = false; 530 for (qp_id = 0; qp_id < nb_qps; qp_id++) { 531 qp = &qps[qp_id]; 532 if (qp->total_dequeue < actual_jobs) { 533 qp->start = rte_rdtsc_precise(); 534 struct rte_regex_ops ** 535 cur_ops_to_enqueue = qp->ops + 536 qp->total_enqueue; 537 538 if (actual_jobs - qp->total_enqueue) 539 qp->total_enqueue += 540 rte_regexdev_enqueue_burst 541 (dev_id, 542 qp_id_base + qp_id, 543 cur_ops_to_enqueue, 544 actual_jobs - 545 qp->total_enqueue); 546 } 547 } 548 for (qp_id = 0; qp_id < nb_qps; qp_id++) { 549 qp = &qps[qp_id]; 550 if (qp->total_dequeue < actual_jobs) { 551 struct rte_regex_ops ** 552 cur_ops_to_dequeue = qp->ops + 553 qp->total_dequeue; 554 555 qp->total_dequeue += 556 rte_regexdev_dequeue_burst 557 (dev_id, 558 qp_id_base + qp_id, 559 cur_ops_to_dequeue, 560 qp->total_enqueue - 561 qp->total_dequeue); 562 qp->cycles += 563 (rte_rdtsc_precise() - qp->start); 564 update = true; 565 } 566 } 567 } while (update); 568 } 569 for (qp_id = 0; qp_id < nb_qps; qp_id++) { 570 qp = &qps[qp_id]; 571 time = (long double)qp->cycles / rte_get_timer_hz(); 572 printf("Core=%u QP=%u Job=%ld Bytes Last Job=%ld Bytes Time=%Lf sec Perf=%Lf " 573 "Gbps\n", rte_lcore_id(), qp_id + qp_id_base, 574 job_len, act_job_len, time, 575 (((double)data_len * nb_iterations * 8) 576 / time) / 1000000000.0); 577 } 578 579 if (rgxc->perf_mode) 580 goto end; 581 for (qp_id = 0; qp_id < nb_qps; qp_id++) { 582 printf("\n############ Core=%u QP=%u ############\n", 583 rte_lcore_id(), qp_id + qp_id_base); 584 qp = &qps[qp_id]; 585 /* Log results per job. */ 586 for (d_ind = 0; d_ind < qp->total_dequeue; d_ind++) { 587 nb_matches = qp->ops[d_ind % actual_jobs]->nb_matches; 588 printf("Job id %"PRIu64" number of matches = %d\n", 589 qp->ops[d_ind]->user_id, nb_matches); 590 qp->total_matches += nb_matches; 591 match = qp->ops[d_ind % actual_jobs]->matches; 592 for (i = 0; i < nb_matches; i++) { 593 printf("match %d, rule = %d, " 594 "start = %d,len = %d\n", 595 i, match->rule_id, match->start_offset, 596 match->len); 597 match++; 598 } 599 } 600 printf("Total matches = %d\n", qp->total_matches); 601 printf("All Matches:\n"); 602 /* Log absolute results. */ 603 for (d_ind = 0; d_ind < qp->total_dequeue; d_ind++) { 604 nb_matches = qp->ops[d_ind % actual_jobs]->nb_matches; 605 qp->total_matches += nb_matches; 606 match = qp->ops[d_ind % actual_jobs]->matches; 607 for (i = 0; i < nb_matches; i++) { 608 printf("start = %d, len = %d, rule = %d\n", 609 match->start_offset + 610 (int)(qp->ops[d_ind % actual_jobs]->user_id * job_len), 611 match->len, match->rule_id); 612 match++; 613 } 614 } 615 } 616 end: 617 for (qp_id = 0; qp_id < qps_used; qp_id++) { 618 qp = &qps[qp_id]; 619 for (i = 0; i < actual_jobs && qp->ops; i++) 620 rte_free(qp->ops[i]); 621 rte_free(qp->ops); 622 qp->ops = NULL; 623 for (i = 0; i < actual_jobs && qp->jobs_ctx; i++) 624 rte_pktmbuf_free(qp->jobs_ctx[i].mbuf); 625 rte_free(qp->jobs_ctx); 626 qp->jobs_ctx = NULL; 627 rte_free(qp->buf); 628 qp->buf = NULL; 629 } 630 rte_mempool_free(mbuf_mp); 631 rte_free(qps); 632 return res; 633 } 634 635 static int 636 distribute_qps_to_lcores(uint32_t nb_cores, uint32_t nb_qps, 637 struct qps_per_lcore **qpl) 638 { 639 int socket; 640 unsigned lcore_id; 641 uint32_t i; 642 uint16_t min_qp_id; 643 uint16_t max_qp_id; 644 struct qps_per_lcore *qps_per_lcore; 645 uint32_t detected_lcores; 646 647 if (nb_qps < nb_cores) { 648 nb_cores = nb_qps; 649 printf("Reducing number of cores to number of QPs (%u)\n", 650 nb_cores); 651 } 652 /* Allocate qps_per_lcore array */ 653 qps_per_lcore = 654 rte_malloc(NULL, sizeof(*qps_per_lcore) * nb_cores, 0); 655 if (!qps_per_lcore) 656 rte_exit(EXIT_FAILURE, "Failed to create qps_per_lcore array\n"); 657 *qpl = qps_per_lcore; 658 detected_lcores = 0; 659 min_qp_id = 0; 660 661 RTE_LCORE_FOREACH_WORKER(lcore_id) { 662 if (detected_lcores >= nb_cores) 663 break; 664 qps_per_lcore[detected_lcores].lcore_id = lcore_id; 665 socket = rte_lcore_to_socket_id(lcore_id); 666 if (socket == SOCKET_ID_ANY) 667 socket = 0; 668 qps_per_lcore[detected_lcores].socket = socket; 669 qps_per_lcore[detected_lcores].qp_id_base = min_qp_id; 670 max_qp_id = min_qp_id + nb_qps / nb_cores - 1; 671 if (nb_qps % nb_cores > detected_lcores) 672 max_qp_id++; 673 qps_per_lcore[detected_lcores].nb_qps = max_qp_id - 674 min_qp_id + 1; 675 min_qp_id = max_qp_id + 1; 676 detected_lcores++; 677 } 678 if (detected_lcores != nb_cores) 679 return -1; 680 681 for (i = 0; i < detected_lcores; i++) { 682 printf("===> Core %d: allocated queues: ", 683 qps_per_lcore[i].lcore_id); 684 min_qp_id = qps_per_lcore[i].qp_id_base; 685 max_qp_id = 686 qps_per_lcore[i].qp_id_base + qps_per_lcore[i].nb_qps; 687 while (min_qp_id < max_qp_id) { 688 printf("%u ", min_qp_id); 689 min_qp_id++; 690 } 691 printf("\n"); 692 } 693 return 0; 694 } 695 696 int 697 main(int argc, char **argv) 698 { 699 char rules_file[MAX_FILE_NAME]; 700 char data_file[MAX_FILE_NAME]; 701 uint32_t nb_jobs = 0; 702 bool perf_mode = 0; 703 uint32_t nb_iterations = 0; 704 int ret; 705 uint16_t nb_max_payload = 0; 706 uint8_t nb_max_matches = 0; 707 uint32_t nb_qps = 1; 708 char *data_buf; 709 long data_len; 710 long job_len; 711 uint32_t nb_lcores = 1, nb_segs = 1; 712 struct regex_conf *rgxc; 713 uint32_t i; 714 struct qps_per_lcore *qps_per_lcore; 715 716 /* Init EAL. */ 717 ret = rte_eal_init(argc, argv); 718 if (ret < 0) 719 rte_exit(EXIT_FAILURE, "EAL init failed\n"); 720 argc -= ret; 721 argv += ret; 722 if (argc > 1) 723 args_parse(argc, argv, rules_file, data_file, &nb_jobs, 724 &perf_mode, &nb_iterations, &nb_qps, 725 &nb_lcores, &nb_segs); 726 727 if (nb_qps == 0) 728 rte_exit(EXIT_FAILURE, "Number of QPs must be greater than 0\n"); 729 if (nb_lcores == 0) 730 rte_exit(EXIT_FAILURE, "Number of lcores must be greater than 0\n"); 731 if (nb_jobs == 0) 732 rte_exit(EXIT_FAILURE, "Number of jobs must be greater than 0\n"); 733 if (distribute_qps_to_lcores(nb_lcores, nb_qps, &qps_per_lcore) < 0) 734 rte_exit(EXIT_FAILURE, "Failed to distribute queues to lcores!\n"); 735 ret = init_port(&nb_max_payload, rules_file, 736 &nb_max_matches, nb_qps); 737 if (ret < 0) 738 rte_exit(EXIT_FAILURE, "init port failed\n"); 739 740 data_len = read_file(data_file, &data_buf); 741 if (data_len <= 0) 742 rte_exit(EXIT_FAILURE, "Error, can't read file, or file is empty.\n"); 743 744 job_len = data_len / nb_jobs; 745 if (job_len == 0) 746 rte_exit(EXIT_FAILURE, "Error, To many jobs, for the given input.\n"); 747 748 if (job_len > nb_max_payload) 749 rte_exit(EXIT_FAILURE, "Error, not enough jobs to cover input.\n"); 750 751 rgxc = rte_malloc(NULL, sizeof(*rgxc) * nb_lcores, 0); 752 if (!rgxc) 753 rte_exit(EXIT_FAILURE, "Failed to create Regex Conf\n"); 754 for (i = 0; i < nb_lcores; i++) { 755 rgxc[i] = (struct regex_conf){ 756 .nb_jobs = nb_jobs, 757 .nb_segs = nb_segs, 758 .perf_mode = perf_mode, 759 .nb_iterations = nb_iterations, 760 .nb_max_matches = nb_max_matches, 761 .nb_qps = qps_per_lcore[i].nb_qps, 762 .qp_id_base = qps_per_lcore[i].qp_id_base, 763 .data_buf = data_buf, 764 .data_len = data_len, 765 .job_len = job_len, 766 }; 767 rte_eal_remote_launch(run_regex, &rgxc[i], 768 qps_per_lcore[i].lcore_id); 769 } 770 rte_eal_mp_wait_lcore(); 771 rte_free(data_buf); 772 rte_free(rgxc); 773 rte_free(qps_per_lcore); 774 return EXIT_SUCCESS; 775 } 776