1 /* SPDX-License-Identifier: BSD-3-Clause 2 * Copyright(c) 2019 Intel Corporation 3 */ 4 5 #include <getopt.h> 6 #include <string.h> 7 #include <arpa/inet.h> 8 #include <sys/socket.h> 9 10 #include <rte_cycles.h> 11 #include <rte_errno.h> 12 #include <rte_ip.h> 13 #include <rte_random.h> 14 #include <rte_malloc.h> 15 #include <rte_lpm.h> 16 #include <rte_lpm6.h> 17 #include <rte_fib.h> 18 #include <rte_fib6.h> 19 20 #define PRINT_USAGE_START "%s [EAL options] --\n" 21 22 #define GET_CB_FIELD(in, fd, base, lim, dlm) do { \ 23 unsigned long val; \ 24 char *end_fld; \ 25 errno = 0; \ 26 val = strtoul((in), &end_fld, (base)); \ 27 if (errno != 0 || end_fld[0] != (dlm) || val > (lim)) \ 28 return -EINVAL; \ 29 (fd) = (typeof(fd))val; \ 30 (in) = end_fld + 1; \ 31 } while (0) 32 33 #define DEF_ROUTES_NUM 0x10000 34 #define DEF_LOOKUP_IPS_NUM 0x100000 35 #define BURST_SZ 64 36 #define DEFAULT_LPM_TBL8 100000U 37 38 #define CMP_FLAG (1 << 0) 39 #define CMP_ALL_FLAG (1 << 1) 40 #define IPV6_FLAG (1 << 2) 41 #define FIB_RIB_TYPE (1 << 3) 42 #define FIB_V4_DIR_TYPE (1 << 4) 43 #define FIB_V6_TRIE_TYPE (1 << 4) 44 #define FIB_TYPE_MASK (FIB_RIB_TYPE|FIB_V4_DIR_TYPE|FIB_V6_TRIE_TYPE) 45 #define SHUFFLE_FLAG (1 << 7) 46 #define DRY_RUN_FLAG (1 << 8) 47 48 static char *distrib_string; 49 static char line[LINE_MAX]; 50 51 enum { 52 RT_PREFIX, 53 RT_NEXTHOP, 54 RT_NUM 55 }; 56 57 #ifndef NIPQUAD 58 #define NIPQUAD_FMT "%u.%u.%u.%u" 59 #define NIPQUAD(addr) \ 60 (unsigned)((unsigned char *)&addr)[3], \ 61 (unsigned)((unsigned char *)&addr)[2], \ 62 (unsigned)((unsigned char *)&addr)[1], \ 63 (unsigned)((unsigned char *)&addr)[0] 64 65 #define NIPQUAD6_FMT "%04x:%04x:%04x:%04x:%04x:%04x:%04x:%04x" 66 #define NIPQUAD6(addr) \ 67 ((uint8_t *)addr)[0] << 8 | \ 68 ((uint8_t *)addr)[1], \ 69 ((uint8_t *)addr)[2] << 8 | \ 70 ((uint8_t *)addr)[3], \ 71 ((uint8_t *)addr)[4] << 8 | \ 72 ((uint8_t *)addr)[5], \ 73 ((uint8_t *)addr)[6] << 8 | \ 74 ((uint8_t *)addr)[7], \ 75 ((uint8_t *)addr)[8] << 8 | \ 76 ((uint8_t *)addr)[9], \ 77 ((uint8_t *)addr)[10] << 8 | \ 78 ((uint8_t *)addr)[11], \ 79 ((uint8_t *)addr)[12] << 8 | \ 80 ((uint8_t *)addr)[13], \ 81 ((uint8_t *)addr)[14] << 8 | \ 82 ((uint8_t *)addr)[15] 83 #endif 84 85 static struct { 86 const char *prgname; 87 const char *routes_file; 88 const char *lookup_ips_file; 89 const char *routes_file_s; 90 const char *lookup_ips_file_s; 91 void *rt; 92 void *lookup_tbl; 93 uint32_t nb_routes; 94 uint32_t nb_lookup_ips; 95 uint32_t nb_lookup_ips_rnd; 96 uint32_t nb_routes_per_depth[128 + 1]; 97 uint32_t flags; 98 uint32_t tbl8; 99 uint8_t ent_sz; 100 uint8_t rnd_lookup_ips_ratio; 101 uint8_t print_fract; 102 uint8_t lookup_fn; 103 } config = { 104 .routes_file = NULL, 105 .lookup_ips_file = NULL, 106 .nb_routes = DEF_ROUTES_NUM, 107 .nb_lookup_ips = DEF_LOOKUP_IPS_NUM, 108 .nb_lookup_ips_rnd = 0, 109 .nb_routes_per_depth = {0}, 110 .flags = FIB_V4_DIR_TYPE, 111 .tbl8 = DEFAULT_LPM_TBL8, 112 .ent_sz = 4, 113 .rnd_lookup_ips_ratio = 0, 114 .print_fract = 10, 115 .lookup_fn = 0 116 }; 117 118 struct rt_rule_4 { 119 uint32_t addr; 120 uint8_t depth; 121 uint64_t nh; 122 }; 123 124 struct rt_rule_6 { 125 uint8_t addr[16]; 126 uint8_t depth; 127 uint64_t nh; 128 }; 129 130 static uint64_t 131 get_rnd_rng(uint64_t l, uint64_t u) 132 { 133 if (l == u) 134 return l; 135 else 136 return (rte_rand() % (u - l) + l); 137 } 138 139 static __rte_always_inline __attribute__((pure)) uint8_t 140 bits_in_nh(uint8_t nh_sz) 141 { 142 return 8 * (1 << nh_sz); 143 } 144 145 static __rte_always_inline __attribute__((pure)) uint64_t 146 get_max_nh(uint8_t nh_sz) 147 { 148 /* min between fib and lpm6 which is 21 bits */ 149 return RTE_MIN(((1ULL << (bits_in_nh(nh_sz) - 1)) - 1), 150 (1ULL << 21) - 1); 151 } 152 153 static int 154 get_fib_type(void) 155 { 156 if (config.flags & IPV6_FLAG) { 157 if ((config.flags & FIB_TYPE_MASK) == FIB_V6_TRIE_TYPE) 158 return RTE_FIB6_TRIE; 159 else 160 return RTE_FIB6_DUMMY; 161 } else { 162 if ((config.flags & FIB_TYPE_MASK) == FIB_V4_DIR_TYPE) 163 return RTE_FIB_DIR24_8; 164 if ((config.flags & FIB_TYPE_MASK) == FIB_RIB_TYPE) 165 return RTE_FIB_DUMMY; 166 } 167 return -1; 168 } 169 170 static int 171 complete_distrib(uint8_t depth_lim, const uint32_t n, uint8_t rpd[], 172 uint32_t nrpd[]) 173 { 174 uint8_t depth; 175 uint32_t nr = 0; 176 uint8_t m = 0; 177 178 /* 179 * complete number of routes for every depth 180 * that was configured with ratio 181 */ 182 for (depth = 0; depth <= depth_lim; depth++) { 183 if (rpd[depth] != 0) { 184 if (rpd[depth] == UINT8_MAX) 185 config.nb_routes_per_depth[depth] = 186 nrpd[depth]; 187 else 188 config.nb_routes_per_depth[depth] = 189 (n * rpd[depth]) / 100; 190 191 nr += config.nb_routes_per_depth[depth]; 192 m++; 193 } 194 } 195 196 if (nr > n) { 197 printf("Too much configured routes\n"); 198 return -1; 199 } 200 201 /*complete number of routes for every unspecified depths*/ 202 for (depth = 0; depth <= depth_lim; depth++) { 203 if (rpd[depth] == 0) { 204 /*we don't need more than two /1 routes*/ 205 uint64_t max_routes_per_depth = 206 1ULL << RTE_MIN(depth, 63); 207 uint32_t avg_routes_left = (n - nr) / 208 (depth_lim + 1 - m++); 209 config.nb_routes_per_depth[depth] = 210 RTE_MIN(max_routes_per_depth, avg_routes_left); 211 nr += config.nb_routes_per_depth[depth]; 212 } 213 } 214 215 return 0; 216 } 217 218 static int 219 parse_distrib(uint8_t depth_lim, const uint32_t n) 220 { 221 uint8_t rpd[128 + 1] = {0}; /*routes ratios per depth including /0 */ 222 uint32_t nrpd[128 + 1] = {0}; /* number of routes per depth */ 223 uint32_t n_routes; 224 uint8_t depth, ratio, ratio_acc = 0; 225 char *in; 226 227 in = strtok(distrib_string, ","); 228 229 /*parse configures routes percentage ratios*/ 230 while (in != NULL) { 231 GET_CB_FIELD(in, depth, 0, UINT8_MAX, ':'); 232 if (in[strlen(in) - 1] == '%') { 233 in[strlen(in) - 1] = 0; 234 GET_CB_FIELD(in, ratio, 0, UINT8_MAX, '\0'); 235 if (depth > depth_lim) { 236 printf("Depth /%d is bigger than maximum " 237 "allowed depth /%d for this AF\n", 238 depth, depth_lim); 239 return -EINVAL; 240 } 241 if (ratio > 100) { 242 printf("Ratio for depth /%d is bigger " 243 "than 100%%\n", depth); 244 return -EINVAL; 245 } 246 if ((depth < 64) && ((n * ratio) / 100) > 247 (1ULL << depth)) { 248 printf("Configured ratio %d%% for depth /%d " 249 "has %d different routes, but maximum " 250 "is %lu\n", ratio, depth, 251 ((n * ratio) / 100), (1UL << depth)); 252 return -EINVAL; 253 } 254 rpd[depth] = ratio; 255 /*configured zero routes for a given depth*/ 256 if (ratio == 0) 257 rpd[depth] = UINT8_MAX; 258 /*sum of all percentage ratios*/ 259 ratio_acc += ratio; 260 } else { 261 GET_CB_FIELD(in, n_routes, 0, UINT32_MAX, '\0'); 262 rpd[depth] = UINT8_MAX; 263 nrpd[depth] = n_routes; 264 } 265 266 /*number of configured depths in*/ 267 in = strtok(NULL, ","); 268 } 269 270 if (ratio_acc > 100) { 271 printf("Total ratio's sum is bigger than 100%%\n"); 272 return -EINVAL; 273 } 274 275 return complete_distrib(depth_lim, n, rpd, nrpd); 276 } 277 278 static void 279 shuffle_rt_4(struct rt_rule_4 *rt, int n) 280 { 281 struct rt_rule_4 tmp; 282 int i, j; 283 284 for (i = 0; i < n; i++) { 285 j = rte_rand() % n; 286 tmp.addr = rt[i].addr; 287 tmp.depth = rt[i].depth; 288 tmp.nh = rt[i].nh; 289 290 rt[i].addr = rt[j].addr; 291 rt[i].depth = rt[j].depth; 292 rt[i].nh = rt[j].nh; 293 294 rt[j].addr = tmp.addr; 295 rt[j].depth = tmp.depth; 296 rt[j].nh = tmp.nh; 297 } 298 } 299 300 static void 301 shuffle_rt_6(struct rt_rule_6 *rt, int n) 302 { 303 struct rt_rule_6 tmp; 304 int i, j; 305 306 for (i = 0; i < n; i++) { 307 j = rte_rand() % n; 308 memcpy(tmp.addr, rt[i].addr, 16); 309 tmp.depth = rt[i].depth; 310 tmp.nh = rt[i].nh; 311 312 memcpy(rt[i].addr, rt[j].addr, 16); 313 rt[i].depth = rt[j].depth; 314 rt[i].nh = rt[j].nh; 315 316 memcpy(rt[j].addr, tmp.addr, 16); 317 rt[j].depth = tmp.depth; 318 rt[j].nh = tmp.nh; 319 } 320 } 321 322 static void 323 gen_random_rt_4(struct rt_rule_4 *rt, int nh_sz) 324 { 325 uint32_t i, j, k = 0; 326 327 if (config.nb_routes_per_depth[0] != 0) { 328 rt[k].addr = 0; 329 rt[k].depth = 0; 330 rt[k++].nh = rte_rand() & get_max_nh(nh_sz); 331 } 332 333 for (i = 1; i <= 32; i++) { 334 double edge = 0; 335 double step; 336 step = (double)(1ULL << i) / config.nb_routes_per_depth[i]; 337 for (j = 0; j < config.nb_routes_per_depth[i]; 338 j++, k++, edge += step) { 339 uint64_t rnd_val = get_rnd_rng((uint64_t)edge, 340 (uint64_t)(edge + step)); 341 rt[k].addr = rnd_val << (32 - i); 342 rt[k].depth = i; 343 rt[k].nh = rte_rand() & get_max_nh(nh_sz); 344 } 345 } 346 } 347 348 static void 349 complete_v6_addr(uint32_t *addr, uint32_t rnd, int n) 350 { 351 int i; 352 353 for (i = 0; i < n; i++) 354 addr[i] = rte_rand(); 355 addr[i++] = rnd; 356 for (; i < 4; i++) 357 addr[i] = 0; 358 } 359 360 static void 361 gen_random_rt_6(struct rt_rule_6 *rt, int nh_sz) 362 { 363 uint32_t a, i, j, k = 0; 364 365 if (config.nb_routes_per_depth[0] != 0) { 366 memset(rt[k].addr, 0, 16); 367 rt[k].depth = 0; 368 rt[k++].nh = rte_rand() & get_max_nh(nh_sz); 369 } 370 371 for (a = 0; a < 4; a++) { 372 for (i = 1; i <= 32; i++) { 373 uint32_t rnd; 374 double edge = 0; 375 double step = (double)(1ULL << i) / 376 config.nb_routes_per_depth[(a * 32) + i]; 377 for (j = 0; j < config.nb_routes_per_depth[a * 32 + i]; 378 j++, k++, edge += step) { 379 uint64_t rnd_val = get_rnd_rng((uint64_t)edge, 380 (uint64_t)(edge + step)); 381 rnd = rte_cpu_to_be_32(rnd_val << (32 - i)); 382 complete_v6_addr((uint32_t *)rt[k].addr, 383 rnd, a); 384 rt[k].depth = (a * 32) + i; 385 rt[k].nh = rte_rand() & get_max_nh(nh_sz); 386 } 387 } 388 } 389 } 390 391 static inline void 392 set_rnd_ipv6(uint8_t *addr, uint8_t *route, int depth) 393 { 394 int i; 395 396 for (i = 0; i < 16; i++) 397 addr[i] = rte_rand(); 398 399 for (i = 0; i < 16; i++) { 400 if (depth >= 8) 401 addr[i] = route[i]; 402 else if (depth > 0) { 403 addr[i] &= (uint16_t)UINT8_MAX >> depth; 404 addr[i] |= route[i] & UINT8_MAX << (8 - depth); 405 } else 406 return; 407 depth -= 8; 408 } 409 } 410 411 static void 412 gen_rnd_lookup_tbl(int af) 413 { 414 uint32_t *tbl4 = config.lookup_tbl; 415 uint8_t *tbl6 = config.lookup_tbl; 416 struct rt_rule_4 *rt4 = (struct rt_rule_4 *)config.rt; 417 struct rt_rule_6 *rt6 = (struct rt_rule_6 *)config.rt; 418 uint32_t i, j; 419 420 if (af == AF_INET) { 421 for (i = 0, j = 0; i < config.nb_lookup_ips; 422 i++, j = (j + 1) % config.nb_routes) { 423 if ((rte_rand() % 100) < config.rnd_lookup_ips_ratio) { 424 tbl4[i] = rte_rand(); 425 config.nb_lookup_ips_rnd++; 426 } else 427 tbl4[i] = rt4[j].addr | (rte_rand() & 428 ((1ULL << (32 - rt4[j].depth)) - 1)); 429 } 430 } else { 431 for (i = 0, j = 0; i < config.nb_lookup_ips; 432 i++, j = (j + 1) % config.nb_routes) { 433 if ((rte_rand() % 100) < config.rnd_lookup_ips_ratio) { 434 set_rnd_ipv6(&tbl6[i * 16], rt6[j].addr, 0); 435 config.nb_lookup_ips_rnd++; 436 } else { 437 set_rnd_ipv6(&tbl6[i * 16], rt6[j].addr, 438 rt6[j].depth); 439 } 440 } 441 } 442 } 443 444 static int 445 _inet_net_pton(int af, char *prefix, void *addr) 446 { 447 const char *dlm = "/"; 448 char *s, *sp; 449 int ret, depth; 450 unsigned int max_depth; 451 452 if ((prefix == NULL) || (addr == NULL)) 453 return -EINVAL; 454 455 s = strtok_r(prefix, dlm, &sp); 456 if (s == NULL) 457 return -EINVAL; 458 459 ret = inet_pton(af, s, addr); 460 if (ret != 1) 461 return -errno; 462 463 s = strtok_r(NULL, dlm, &sp); 464 max_depth = (af == AF_INET) ? 32 : 128; 465 GET_CB_FIELD(s, depth, 0, max_depth, 0); 466 467 return depth; 468 } 469 470 static int 471 parse_rt_4(FILE *f) 472 { 473 int ret, i, j = 0; 474 char *s, *sp, *in[RT_NUM]; 475 static const char *dlm = " \t\n"; 476 int string_tok_nb = RTE_DIM(in); 477 struct rt_rule_4 *rt; 478 479 rt = (struct rt_rule_4 *)config.rt; 480 481 while (fgets(line, sizeof(line), f) != NULL) { 482 s = line; 483 for (i = 0; i != string_tok_nb; i++) { 484 in[i] = strtok_r(s, dlm, &sp); 485 if (in[i] == NULL) 486 return -EINVAL; 487 s = NULL; 488 } 489 490 ret = _inet_net_pton(AF_INET, in[RT_PREFIX], &rt[j].addr); 491 if (ret == -1) 492 return -errno; 493 494 rt[j].addr = rte_be_to_cpu_32(rt[j].addr); 495 rt[j].depth = ret; 496 config.nb_routes_per_depth[ret]++; 497 GET_CB_FIELD(in[RT_NEXTHOP], rt[j].nh, 0, 498 UINT32_MAX, 0); 499 j++; 500 } 501 return 0; 502 } 503 504 static int 505 parse_rt_6(FILE *f) 506 { 507 int ret, i, j = 0; 508 char *s, *sp, *in[RT_NUM]; 509 static const char *dlm = " \t\n"; 510 int string_tok_nb = RTE_DIM(in); 511 struct rt_rule_6 *rt; 512 513 rt = (struct rt_rule_6 *)config.rt; 514 515 while (fgets(line, sizeof(line), f) != NULL) { 516 s = line; 517 for (i = 0; i != string_tok_nb; i++) { 518 in[i] = strtok_r(s, dlm, &sp); 519 if (in[i] == NULL) 520 return -EINVAL; 521 s = NULL; 522 } 523 524 ret = _inet_net_pton(AF_INET6, in[RT_PREFIX], rt[j].addr); 525 if (ret < 0) 526 return ret; 527 528 rt[j].depth = ret; 529 config.nb_routes_per_depth[ret]++; 530 GET_CB_FIELD(in[RT_NEXTHOP], rt[j].nh, 0, 531 UINT32_MAX, 0); 532 j++; 533 } 534 535 return 0; 536 } 537 538 static int 539 parse_lookup(FILE *f, int af) 540 { 541 int ret, i = 0; 542 uint8_t *tbl = (uint8_t *)config.lookup_tbl; 543 int step = (af == AF_INET) ? 4 : 16; 544 char *s; 545 546 while (fgets(line, sizeof(line), f) != NULL) { 547 s = strtok(line, " \t\n"); 548 if (s == NULL) 549 return -EINVAL; 550 ret = inet_pton(af, s, &tbl[i]); 551 if (ret != 1) 552 return -EINVAL; 553 i += step; 554 } 555 return 0; 556 } 557 558 static int 559 dump_lookup(int af) 560 { 561 FILE *f; 562 uint32_t *tbl4 = config.lookup_tbl; 563 uint8_t *tbl6 = config.lookup_tbl; 564 uint32_t i; 565 566 f = fopen(config.lookup_ips_file_s, "w"); 567 if (f == NULL) { 568 printf("Can not open file %s\n", config.lookup_ips_file_s); 569 return -1; 570 } 571 572 if (af == AF_INET) { 573 for (i = 0; i < config.nb_lookup_ips; i++) 574 fprintf(f, NIPQUAD_FMT"\n", NIPQUAD(tbl4[i])); 575 } else { 576 for (i = 0; i < config.nb_lookup_ips; i++) 577 fprintf(f, NIPQUAD6_FMT"\n", NIPQUAD6(&tbl6[i * 16])); 578 } 579 fclose(f); 580 return 0; 581 } 582 583 static void 584 print_config(void) 585 { 586 uint8_t depth_lim; 587 char dlm; 588 int i; 589 590 depth_lim = ((config.flags & IPV6_FLAG) == IPV6_FLAG) ? 128 : 32; 591 592 fprintf(stdout, 593 "Routes total: %u\n" 594 "Routes distribution:\n", config.nb_routes); 595 596 for (i = 1; i <= depth_lim; i++) { 597 fprintf(stdout, 598 "depth /%d:%u", i, config.nb_routes_per_depth[i]); 599 if (i % 4 == 0) 600 dlm = '\n'; 601 else 602 dlm = '\t'; 603 fprintf(stdout, "%c", dlm); 604 } 605 606 fprintf(stdout, 607 "Lookup tuples: %u\n" 608 "Configured ratios of random ips for lookup: %u\n" 609 "Random lookup ips: %u\n", 610 config.nb_lookup_ips, config.rnd_lookup_ips_ratio, 611 config.nb_lookup_ips_rnd); 612 } 613 614 static void 615 print_usage(void) 616 { 617 fprintf(stdout, 618 PRINT_USAGE_START 619 "[-f <routes file>]\n" 620 "[-t <ip's file for lookup>]\n" 621 "[-n <number of routes (if -f is not specified)>]\n" 622 "[-l <number of ip's for lookup (if -t is not specified)>]\n" 623 "[-d <\",\" separated \"depth:n%%\"routes depth distribution" 624 "(if -f is not specified)>]\n" 625 "[-r <percentage ratio of random ip's to lookup" 626 "(if -t is not specified)>]\n" 627 "[-c <do comarison with LPM library>]\n" 628 "[-6 <do tests with ipv6 (default ipv4)>]\n" 629 "[-s <shuffle randomly generated routes>]\n" 630 "[-a <check nexthops for all ipv4 address space" 631 "(only valid with -c)>]\n" 632 "[-b <fib algorithm>]\n\tavailable options for ipv4\n" 633 "\t\trib - RIB based FIB\n" 634 "\t\tdir - DIR24_8 based FIB\n" 635 "\tavailable options for ipv6:\n" 636 "\t\trib - RIB based FIB\n" 637 "\t\ttrie - TRIE based FIB\n" 638 "defaults are: dir for ipv4 and trie for ipv6\n" 639 "[-e <entry size (valid only for dir and trie fib types): " 640 "1/2/4/8 (default 4)>]\n" 641 "[-g <number of tbl8's for dir24_8 or trie FIBs>]\n" 642 "[-w <path to the file to dump routing table>]\n" 643 "[-u <path to the file to dump ip's for lookup>]\n" 644 "[-v <type of loookup function:" 645 "\ts1, s2, s3 (3 types of scalar), v (vector) -" 646 " for DIR24_8 based FIB\n" 647 "\ts, v - for TRIE based ipv6 FIB>]\n", 648 config.prgname); 649 } 650 651 static int 652 check_config(void) 653 { 654 if ((config.routes_file == NULL) && (config.lookup_ips_file != NULL)) { 655 printf("-t option only valid with -f option\n"); 656 return -1; 657 } 658 659 if ((config.flags & CMP_ALL_FLAG) && (config.flags & IPV6_FLAG)) { 660 printf("-a flag is only valid for ipv4\n"); 661 return -1; 662 } 663 664 if ((config.flags & CMP_ALL_FLAG) && 665 ((config.flags & CMP_FLAG) != CMP_FLAG)) { 666 printf("-a flag is valid only with -c flag\n"); 667 return -1; 668 } 669 670 if (!((config.ent_sz == 1) || (config.ent_sz == 2) || 671 (config.ent_sz == 4) || (config.ent_sz == 8))) { 672 printf("wrong -e option %d, can be 1 or 2 or 4 or 8\n", 673 config.ent_sz); 674 return -1; 675 } 676 677 if ((config.ent_sz == 1) && (config.flags & IPV6_FLAG)) { 678 printf("-e 1 is valid only for ipv4\n"); 679 return -1; 680 } 681 return 0; 682 } 683 684 static void 685 parse_opts(int argc, char **argv) 686 { 687 int opt; 688 char *endptr; 689 690 while ((opt = getopt(argc, argv, "f:t:n:d:l:r:c6ab:e:g:w:u:sv:")) != 691 -1) { 692 switch (opt) { 693 case 'f': 694 config.routes_file = optarg; 695 break; 696 case 't': 697 config.lookup_ips_file = optarg; 698 break; 699 case 'w': 700 config.routes_file_s = optarg; 701 config.flags |= DRY_RUN_FLAG; 702 break; 703 case 'u': 704 config.lookup_ips_file_s = optarg; 705 config.flags |= DRY_RUN_FLAG; 706 break; 707 case 'n': 708 errno = 0; 709 config.nb_routes = strtoul(optarg, &endptr, 10); 710 if ((errno != 0) || (config.nb_routes == 0)) { 711 print_usage(); 712 rte_exit(-EINVAL, "Invalid option -n\n"); 713 } 714 break; 715 case 'd': 716 distrib_string = optarg; 717 break; 718 case 'l': 719 errno = 0; 720 config.nb_lookup_ips = strtoul(optarg, &endptr, 10); 721 if ((errno != 0) || (config.nb_lookup_ips == 0)) { 722 print_usage(); 723 rte_exit(-EINVAL, "Invalid option -l\n"); 724 } 725 break; 726 case 'r': 727 errno = 0; 728 config.rnd_lookup_ips_ratio = 729 strtoul(optarg, &endptr, 10); 730 if ((errno != 0) || 731 (config.rnd_lookup_ips_ratio == 0) || 732 (config.rnd_lookup_ips_ratio >= 100)) { 733 print_usage(); 734 rte_exit(-EINVAL, "Invalid option -r\n"); 735 } 736 break; 737 case 's': 738 config.flags |= SHUFFLE_FLAG; 739 break; 740 case 'c': 741 config.flags |= CMP_FLAG; 742 break; 743 case '6': 744 config.flags |= IPV6_FLAG; 745 break; 746 case 'a': 747 config.flags |= CMP_ALL_FLAG; 748 break; 749 case 'b': 750 if (strcmp(optarg, "rib") == 0) { 751 config.flags &= ~FIB_TYPE_MASK; 752 config.flags |= FIB_RIB_TYPE; 753 } else if (strcmp(optarg, "dir") == 0) { 754 config.flags &= ~FIB_TYPE_MASK; 755 config.flags |= FIB_V4_DIR_TYPE; 756 } else if (strcmp(optarg, "trie") == 0) { 757 config.flags &= ~FIB_TYPE_MASK; 758 config.flags |= FIB_V6_TRIE_TYPE; 759 } else 760 rte_exit(-EINVAL, "Invalid option -b\n"); 761 break; 762 case 'e': 763 errno = 0; 764 config.ent_sz = strtoul(optarg, &endptr, 10); 765 if (errno != 0) { 766 print_usage(); 767 rte_exit(-EINVAL, "Invalid option -e\n"); 768 } 769 break; 770 case 'g': 771 errno = 0; 772 config.tbl8 = strtoul(optarg, &endptr, 10); 773 if ((errno != 0) || (config.tbl8 == 0)) { 774 print_usage(); 775 rte_exit(-EINVAL, "Invalid option -g\n"); 776 } 777 break; 778 case 'v': 779 if ((strcmp(optarg, "s1") == 0) || 780 (strcmp(optarg, "s") == 0)) { 781 config.lookup_fn = 1; 782 break; 783 } else if (strcmp(optarg, "v") == 0) { 784 config.lookup_fn = 2; 785 break; 786 } else if (strcmp(optarg, "s2") == 0) { 787 config.lookup_fn = 3; 788 break; 789 } else if (strcmp(optarg, "s3") == 0) { 790 config.lookup_fn = 4; 791 break; 792 } 793 print_usage(); 794 rte_exit(-EINVAL, "Invalid option -v %s\n", optarg); 795 default: 796 print_usage(); 797 rte_exit(-EINVAL, "Invalid options\n"); 798 } 799 } 800 } 801 802 static int 803 dump_rt_4(struct rt_rule_4 *rt) 804 { 805 FILE *f; 806 uint32_t i; 807 808 f = fopen(config.routes_file_s, "w"); 809 if (f == NULL) { 810 printf("Can not open file %s\n", config.routes_file_s); 811 return -1; 812 } 813 814 for (i = 0; i < config.nb_routes; i++) 815 fprintf(f, NIPQUAD_FMT"/%d %"PRIu64"\n", NIPQUAD(rt[i].addr), 816 rt[i].depth, rt[i].nh); 817 818 fclose(f); 819 return 0; 820 } 821 822 static inline void 823 print_depth_err(void) 824 { 825 printf("LPM does not support /0 prefix length (default route), use " 826 "-d 0:0 option or remove /0 prefix from routes file\n"); 827 } 828 829 static int 830 run_v4(void) 831 { 832 uint64_t start, acc; 833 uint64_t def_nh = 0; 834 struct rte_fib *fib; 835 struct rte_fib_conf conf = {0}; 836 struct rt_rule_4 *rt; 837 uint32_t i, j, k; 838 int ret = 0; 839 struct rte_lpm *lpm = NULL; 840 struct rte_lpm_config lpm_conf; 841 uint32_t *tbl4 = config.lookup_tbl; 842 uint64_t fib_nh[BURST_SZ]; 843 uint32_t lpm_nh[BURST_SZ]; 844 845 rt = (struct rt_rule_4 *)config.rt; 846 847 if (config.flags & DRY_RUN_FLAG) { 848 if (config.routes_file_s != NULL) 849 ret = dump_rt_4(rt); 850 if (ret != 0) 851 return ret; 852 if (config.lookup_ips_file_s != NULL) 853 ret = dump_lookup(AF_INET); 854 return ret; 855 } 856 857 conf.type = get_fib_type(); 858 conf.default_nh = def_nh; 859 conf.max_routes = config.nb_routes * 2; 860 conf.rib_ext_sz = 0; 861 if (conf.type == RTE_FIB_DIR24_8) { 862 conf.dir24_8.nh_sz = __builtin_ctz(config.ent_sz); 863 conf.dir24_8.num_tbl8 = RTE_MIN(config.tbl8, 864 get_max_nh(conf.dir24_8.nh_sz)); 865 } 866 867 fib = rte_fib_create("test", -1, &conf); 868 if (fib == NULL) { 869 printf("Can not alloc FIB, err %d\n", rte_errno); 870 return -rte_errno; 871 } 872 873 if (config.lookup_fn != 0) { 874 if (config.lookup_fn == 1) 875 ret = rte_fib_select_lookup(fib, 876 RTE_FIB_LOOKUP_DIR24_8_SCALAR_MACRO); 877 else if (config.lookup_fn == 2) 878 ret = rte_fib_select_lookup(fib, 879 RTE_FIB_LOOKUP_DIR24_8_VECTOR_AVX512); 880 else if (config.lookup_fn == 3) 881 ret = rte_fib_select_lookup(fib, 882 RTE_FIB_LOOKUP_DIR24_8_SCALAR_INLINE); 883 else if (config.lookup_fn == 4) 884 ret = rte_fib_select_lookup(fib, 885 RTE_FIB_LOOKUP_DIR24_8_SCALAR_UNI); 886 else 887 ret = -EINVAL; 888 if (ret != 0) { 889 printf("Can not init lookup function\n"); 890 return ret; 891 } 892 } 893 894 for (k = config.print_fract, i = 0; k > 0; k--) { 895 start = rte_rdtsc_precise(); 896 for (j = 0; j < (config.nb_routes - i) / k; j++) { 897 ret = rte_fib_add(fib, rt[i + j].addr, rt[i + j].depth, 898 rt[i + j].nh); 899 if (unlikely(ret != 0)) { 900 printf("Can not add a route to FIB, err %d\n", 901 ret); 902 return -ret; 903 } 904 } 905 printf("AVG FIB add %"PRIu64"\n", 906 (rte_rdtsc_precise() - start) / j); 907 i += j; 908 } 909 910 if (config.flags & CMP_FLAG) { 911 lpm_conf.max_rules = config.nb_routes * 2; 912 lpm_conf.number_tbl8s = RTE_MAX(conf.dir24_8.num_tbl8, 913 config.tbl8); 914 915 lpm = rte_lpm_create("test_lpm", -1, &lpm_conf); 916 if (lpm == NULL) { 917 printf("Can not alloc LPM, err %d\n", rte_errno); 918 return -rte_errno; 919 } 920 for (k = config.print_fract, i = 0; k > 0; k--) { 921 start = rte_rdtsc_precise(); 922 for (j = 0; j < (config.nb_routes - i) / k; j++) { 923 ret = rte_lpm_add(lpm, rt[i + j].addr, 924 rt[i + j].depth, rt[i + j].nh); 925 if (ret != 0) { 926 if (rt[i + j].depth == 0) 927 print_depth_err(); 928 printf("Can not add a route to LPM, " 929 "err %d\n", ret); 930 return -ret; 931 } 932 } 933 printf("AVG LPM add %"PRIu64"\n", 934 (rte_rdtsc_precise() - start) / j); 935 i += j; 936 } 937 } 938 939 acc = 0; 940 for (i = 0; i < config.nb_lookup_ips; i += BURST_SZ) { 941 start = rte_rdtsc_precise(); 942 ret = rte_fib_lookup_bulk(fib, tbl4 + i, fib_nh, BURST_SZ); 943 acc += rte_rdtsc_precise() - start; 944 if (ret != 0) { 945 printf("FIB lookup fails, err %d\n", ret); 946 return -ret; 947 } 948 } 949 printf("AVG FIB lookup %.1f\n", (double)acc / (double)i); 950 951 if (config.flags & CMP_FLAG) { 952 acc = 0; 953 for (i = 0; i < config.nb_lookup_ips; i += BURST_SZ) { 954 start = rte_rdtsc_precise(); 955 ret = rte_lpm_lookup_bulk(lpm, tbl4 + i, lpm_nh, 956 BURST_SZ); 957 acc += rte_rdtsc_precise() - start; 958 if (ret != 0) { 959 printf("LPM lookup fails, err %d\n", ret); 960 return -ret; 961 } 962 } 963 printf("AVG LPM lookup %.1f\n", (double)acc / (double)i); 964 965 for (i = 0; i < config.nb_lookup_ips; i += BURST_SZ) { 966 rte_fib_lookup_bulk(fib, tbl4 + i, fib_nh, BURST_SZ); 967 rte_lpm_lookup_bulk(lpm, tbl4 + i, lpm_nh, BURST_SZ); 968 for (j = 0; j < BURST_SZ; j++) { 969 struct rte_lpm_tbl_entry *tbl; 970 tbl = (struct rte_lpm_tbl_entry *)&lpm_nh[j]; 971 if ((fib_nh[j] != tbl->next_hop) && 972 !((tbl->valid == 0) && 973 (fib_nh[j] == def_nh))) { 974 printf("FAIL\n"); 975 return -1; 976 } 977 } 978 } 979 printf("FIB and LPM lookup returns same values\n"); 980 } 981 982 for (k = config.print_fract, i = 0; k > 0; k--) { 983 start = rte_rdtsc_precise(); 984 for (j = 0; j < (config.nb_routes - i) / k; j++) 985 rte_fib_delete(fib, rt[i + j].addr, rt[i + j].depth); 986 987 printf("AVG FIB delete %"PRIu64"\n", 988 (rte_rdtsc_precise() - start) / j); 989 i += j; 990 } 991 992 if (config.flags & CMP_FLAG) { 993 for (k = config.print_fract, i = 0; k > 0; k--) { 994 start = rte_rdtsc_precise(); 995 for (j = 0; j < (config.nb_routes - i) / k; j++) 996 rte_lpm_delete(lpm, rt[i + j].addr, 997 rt[i + j].depth); 998 999 printf("AVG LPM delete %"PRIu64"\n", 1000 (rte_rdtsc_precise() - start) / j); 1001 i += j; 1002 } 1003 } 1004 1005 return 0; 1006 } 1007 1008 static int 1009 dump_rt_6(struct rt_rule_6 *rt) 1010 { 1011 FILE *f; 1012 uint32_t i; 1013 1014 f = fopen(config.routes_file_s, "w"); 1015 if (f == NULL) { 1016 printf("Can not open file %s\n", config.routes_file_s); 1017 return -1; 1018 } 1019 1020 for (i = 0; i < config.nb_routes; i++) { 1021 fprintf(f, NIPQUAD6_FMT"/%d %"PRIu64"\n", NIPQUAD6(rt[i].addr), 1022 rt[i].depth, rt[i].nh); 1023 1024 } 1025 fclose(f); 1026 return 0; 1027 } 1028 1029 static int 1030 run_v6(void) 1031 { 1032 uint64_t start, acc; 1033 uint64_t def_nh = 0; 1034 struct rte_fib6 *fib; 1035 struct rte_fib6_conf conf = {0}; 1036 struct rt_rule_6 *rt; 1037 uint32_t i, j, k; 1038 int ret = 0; 1039 struct rte_lpm6 *lpm = NULL; 1040 struct rte_lpm6_config lpm_conf; 1041 uint8_t *tbl6; 1042 uint64_t fib_nh[BURST_SZ]; 1043 int32_t lpm_nh[BURST_SZ]; 1044 1045 rt = (struct rt_rule_6 *)config.rt; 1046 tbl6 = config.lookup_tbl; 1047 1048 if (config.flags & DRY_RUN_FLAG) { 1049 if (config.routes_file_s != NULL) 1050 ret = dump_rt_6(rt); 1051 if (ret != 0) 1052 return ret; 1053 if (config.lookup_ips_file_s != NULL) 1054 ret = dump_lookup(AF_INET6); 1055 return ret; 1056 } 1057 1058 conf.type = get_fib_type(); 1059 conf.default_nh = def_nh; 1060 conf.max_routes = config.nb_routes * 2; 1061 conf.rib_ext_sz = 0; 1062 if (conf.type == RTE_FIB6_TRIE) { 1063 conf.trie.nh_sz = __builtin_ctz(config.ent_sz); 1064 conf.trie.num_tbl8 = RTE_MIN(config.tbl8, 1065 get_max_nh(conf.trie.nh_sz)); 1066 } 1067 1068 fib = rte_fib6_create("test", -1, &conf); 1069 if (fib == NULL) { 1070 printf("Can not alloc FIB, err %d\n", rte_errno); 1071 return -rte_errno; 1072 } 1073 1074 if (config.lookup_fn != 0) { 1075 if (config.lookup_fn == 1) 1076 ret = rte_fib6_select_lookup(fib, 1077 RTE_FIB6_LOOKUP_TRIE_SCALAR); 1078 else if (config.lookup_fn == 2) 1079 ret = rte_fib6_select_lookup(fib, 1080 RTE_FIB6_LOOKUP_TRIE_VECTOR_AVX512); 1081 else 1082 ret = -EINVAL; 1083 if (ret != 0) { 1084 printf("Can not init lookup function\n"); 1085 return ret; 1086 } 1087 } 1088 1089 for (k = config.print_fract, i = 0; k > 0; k--) { 1090 start = rte_rdtsc_precise(); 1091 for (j = 0; j < (config.nb_routes - i) / k; j++) { 1092 ret = rte_fib6_add(fib, rt[i + j].addr, 1093 rt[i + j].depth, rt[i + j].nh); 1094 if (unlikely(ret != 0)) { 1095 printf("Can not add a route to FIB, err %d\n", 1096 ret); 1097 return -ret; 1098 } 1099 } 1100 printf("AVG FIB add %"PRIu64"\n", 1101 (rte_rdtsc_precise() - start) / j); 1102 i += j; 1103 } 1104 1105 if (config.flags & CMP_FLAG) { 1106 lpm_conf.max_rules = config.nb_routes * 2; 1107 lpm_conf.number_tbl8s = RTE_MAX(conf.trie.num_tbl8, 1108 config.tbl8); 1109 1110 lpm = rte_lpm6_create("test_lpm", -1, &lpm_conf); 1111 if (lpm == NULL) { 1112 printf("Can not alloc LPM, err %d\n", rte_errno); 1113 return -rte_errno; 1114 } 1115 for (k = config.print_fract, i = 0; k > 0; k--) { 1116 start = rte_rdtsc_precise(); 1117 for (j = 0; j < (config.nb_routes - i) / k; j++) { 1118 ret = rte_lpm6_add(lpm, rt[i + j].addr, 1119 rt[i + j].depth, rt[i + j].nh); 1120 if (ret != 0) { 1121 if (rt[i + j].depth == 0) 1122 print_depth_err(); 1123 printf("Can not add a route to LPM, " 1124 "err %d\n", ret); 1125 return -ret; 1126 } 1127 } 1128 printf("AVG LPM add %"PRIu64"\n", 1129 (rte_rdtsc_precise() - start) / j); 1130 i += j; 1131 } 1132 } 1133 1134 acc = 0; 1135 for (i = 0; i < config.nb_lookup_ips; i += BURST_SZ) { 1136 start = rte_rdtsc_precise(); 1137 ret = rte_fib6_lookup_bulk(fib, (uint8_t (*)[16])(tbl6 + i*16), 1138 fib_nh, BURST_SZ); 1139 acc += rte_rdtsc_precise() - start; 1140 if (ret != 0) { 1141 printf("FIB lookup fails, err %d\n", ret); 1142 return -ret; 1143 } 1144 } 1145 printf("AVG FIB lookup %.1f\n", (double)acc / (double)i); 1146 1147 if (config.flags & CMP_FLAG) { 1148 acc = 0; 1149 for (i = 0; i < config.nb_lookup_ips; i += BURST_SZ) { 1150 start = rte_rdtsc_precise(); 1151 ret = rte_lpm6_lookup_bulk_func(lpm, 1152 (uint8_t (*)[16])(tbl6 + i*16), 1153 lpm_nh, BURST_SZ); 1154 acc += rte_rdtsc_precise() - start; 1155 if (ret != 0) { 1156 printf("LPM lookup fails, err %d\n", ret); 1157 return -ret; 1158 } 1159 } 1160 printf("AVG LPM lookup %.1f\n", (double)acc / (double)i); 1161 1162 for (i = 0; i < config.nb_lookup_ips; i += BURST_SZ) { 1163 rte_fib6_lookup_bulk(fib, 1164 (uint8_t (*)[16])(tbl6 + i*16), 1165 fib_nh, BURST_SZ); 1166 rte_lpm6_lookup_bulk_func(lpm, 1167 (uint8_t (*)[16])(tbl6 + i*16), 1168 lpm_nh, BURST_SZ); 1169 for (j = 0; j < BURST_SZ; j++) { 1170 if ((fib_nh[j] != (uint32_t)lpm_nh[j]) && 1171 !((lpm_nh[j] == -1) && 1172 (fib_nh[j] == def_nh))) { 1173 printf("FAIL\n"); 1174 return -1; 1175 } 1176 } 1177 } 1178 printf("FIB and LPM lookup returns same values\n"); 1179 } 1180 1181 for (k = config.print_fract, i = 0; k > 0; k--) { 1182 start = rte_rdtsc_precise(); 1183 for (j = 0; j < (config.nb_routes - i) / k; j++) 1184 rte_fib6_delete(fib, rt[i + j].addr, rt[i + j].depth); 1185 1186 printf("AVG FIB delete %"PRIu64"\n", 1187 (rte_rdtsc_precise() - start) / j); 1188 i += j; 1189 } 1190 1191 if (config.flags & CMP_FLAG) { 1192 for (k = config.print_fract, i = 0; k > 0; k--) { 1193 start = rte_rdtsc_precise(); 1194 for (j = 0; j < (config.nb_routes - i) / k; j++) 1195 rte_lpm6_delete(lpm, rt[i + j].addr, 1196 rt[i + j].depth); 1197 1198 printf("AVG LPM delete %"PRIu64"\n", 1199 (rte_rdtsc_precise() - start) / j); 1200 i += j; 1201 } 1202 } 1203 return 0; 1204 } 1205 1206 int 1207 main(int argc, char **argv) 1208 { 1209 int ret, af, rt_ent_sz, lookup_ent_sz; 1210 FILE *fr = NULL; 1211 FILE *fl = NULL; 1212 uint8_t depth_lim; 1213 1214 ret = rte_eal_init(argc, argv); 1215 if (ret < 0) 1216 rte_panic("Cannot init EAL\n"); 1217 1218 argc -= ret; 1219 argv += ret; 1220 1221 config.prgname = argv[0]; 1222 1223 parse_opts(argc, argv); 1224 1225 ret = check_config(); 1226 if (ret != 0) 1227 rte_exit(-ret, "Bad configuration\n"); 1228 1229 af = ((config.flags & IPV6_FLAG) == 0) ? AF_INET : AF_INET6; 1230 depth_lim = (af == AF_INET) ? 32 : 128; 1231 rt_ent_sz = (af == AF_INET) ? sizeof(struct rt_rule_4) : 1232 sizeof(struct rt_rule_6); 1233 lookup_ent_sz = (af == AF_INET) ? 4 : 16; 1234 1235 /* Count number of rules in file*/ 1236 if (config.routes_file != NULL) { 1237 fr = fopen(config.routes_file, "r"); 1238 if (fr == NULL) 1239 rte_exit(-errno, "Can not open file with routes %s\n", 1240 config.routes_file); 1241 1242 config.nb_routes = 0; 1243 while (fgets(line, sizeof(line), fr) != NULL) 1244 config.nb_routes++; 1245 rewind(fr); 1246 } 1247 1248 /* Count number of ip's in file*/ 1249 if (config.lookup_ips_file != NULL) { 1250 fl = fopen(config.lookup_ips_file, "r"); 1251 if (fl == NULL) 1252 rte_exit(-errno, "Can not open file with ip's %s\n", 1253 config.lookup_ips_file); 1254 1255 config.nb_lookup_ips = 0; 1256 while (fgets(line, sizeof(line), fl) != NULL) 1257 config.nb_lookup_ips++; 1258 rewind(fl); 1259 } 1260 1261 /* Alloc routes table*/ 1262 config.rt = rte_malloc(NULL, rt_ent_sz * config.nb_routes, 0); 1263 if (config.rt == NULL) 1264 rte_exit(-ENOMEM, "Can not alloc rt\n"); 1265 1266 /* Alloc table with ip's for lookup*/ 1267 config.lookup_tbl = rte_malloc(NULL, lookup_ent_sz * 1268 config.nb_lookup_ips, 0); 1269 if (config.lookup_tbl == NULL) 1270 rte_exit(-ENOMEM, "Can not alloc lookup table\n"); 1271 1272 /* Fill routes table */ 1273 if (fr == NULL) { 1274 if (distrib_string != NULL) 1275 ret = parse_distrib(depth_lim, config.nb_routes); 1276 else { 1277 uint8_t rpd[129] = {0}; 1278 uint32_t nrpd[129] = {0}; 1279 ret = complete_distrib(depth_lim, config.nb_routes, 1280 rpd, nrpd); 1281 } 1282 if (ret != 0) 1283 rte_exit(-ret, 1284 "Bad routes distribution configuration\n"); 1285 if (af == AF_INET) { 1286 gen_random_rt_4(config.rt, 1287 __builtin_ctz(config.ent_sz)); 1288 if (config.flags & SHUFFLE_FLAG) 1289 shuffle_rt_4(config.rt, config.nb_routes); 1290 } else { 1291 gen_random_rt_6(config.rt, 1292 __builtin_ctz(config.ent_sz)); 1293 if (config.flags & SHUFFLE_FLAG) 1294 shuffle_rt_6(config.rt, config.nb_routes); 1295 } 1296 } else { 1297 if (af == AF_INET) 1298 ret = parse_rt_4(fr); 1299 else 1300 ret = parse_rt_6(fr); 1301 1302 if (ret != 0) { 1303 rte_exit(-ret, "failed to parse routes file %s\n", 1304 config.routes_file); 1305 } 1306 } 1307 1308 /* Fill lookup table with ip's*/ 1309 if (fl == NULL) 1310 gen_rnd_lookup_tbl(af); 1311 else { 1312 ret = parse_lookup(fl, af); 1313 if (ret != 0) 1314 rte_exit(-ret, "failed to parse lookup file\n"); 1315 } 1316 1317 print_config(); 1318 1319 if (af == AF_INET) 1320 ret = run_v4(); 1321 else 1322 ret = run_v6(); 1323 1324 return ret; 1325 } 1326