1 /* SPDX-License-Identifier: BSD-3-Clause 2 * Copyright(c) 2010-2016 Intel Corporation 3 */ 4 5 #include <string.h> 6 #include "test_table_combined.h" 7 #include "test_table.h" 8 #include <rte_table_lpm_ipv6.h> 9 10 #define MAX_TEST_KEYS 128 11 #define N_PACKETS 50 12 13 enum check_table_result { 14 CHECK_TABLE_OK, 15 CHECK_TABLE_PORT_CONFIG, 16 CHECK_TABLE_PORT_ENABLE, 17 CHECK_TABLE_TABLE_CONFIG, 18 CHECK_TABLE_ENTRY_ADD, 19 CHECK_TABLE_DEFAULT_ENTRY_ADD, 20 CHECK_TABLE_CONNECT, 21 CHECK_TABLE_MANAGE_ERROR, 22 CHECK_TABLE_CONSISTENCY, 23 CHECK_TABLE_NO_TRAFFIC, 24 CHECK_TABLE_INVALID_PARAMETER, 25 }; 26 27 struct table_packets { 28 uint32_t hit_packet[MAX_TEST_KEYS]; 29 uint32_t miss_packet[MAX_TEST_KEYS]; 30 uint32_t n_hit_packets; 31 uint32_t n_miss_packets; 32 }; 33 34 combined_table_test table_tests_combined[] = { 35 test_table_lpm_combined, 36 test_table_lpm_ipv6_combined, 37 test_table_hash8lru, 38 test_table_hash8ext, 39 test_table_hash16lru, 40 test_table_hash16ext, 41 test_table_hash32lru, 42 test_table_hash32ext, 43 test_table_hash_cuckoo_combined, 44 }; 45 46 unsigned n_table_tests_combined = RTE_DIM(table_tests_combined); 47 48 /* Generic port tester function */ 49 static int 50 test_table_type(struct rte_table_ops *table_ops, void *table_args, 51 void *key, struct table_packets *table_packets, 52 struct manage_ops *manage_ops, unsigned n_ops) 53 { 54 uint32_t ring_in_id, table_id, ring_out_id, ring_out_2_id; 55 unsigned i; 56 57 RTE_SET_USED(manage_ops); 58 RTE_SET_USED(n_ops); 59 /* Create pipeline */ 60 struct rte_pipeline_params pipeline_params = { 61 .name = "pipeline", 62 .socket_id = 0, 63 }; 64 65 struct rte_pipeline *pipeline = rte_pipeline_create(&pipeline_params); 66 67 /* Create input ring */ 68 struct rte_port_ring_reader_params ring_params_rx = { 69 .ring = RING_RX, 70 }; 71 72 struct rte_port_ring_writer_params ring_params_tx = { 73 .ring = RING_RX, 74 .tx_burst_sz = RTE_PORT_IN_BURST_SIZE_MAX, 75 }; 76 77 struct rte_pipeline_port_in_params ring_in_params = { 78 .ops = &rte_port_ring_reader_ops, 79 .arg_create = (void *)&ring_params_rx, 80 .f_action = NULL, 81 .burst_size = RTE_PORT_IN_BURST_SIZE_MAX, 82 }; 83 84 if (rte_pipeline_port_in_create(pipeline, &ring_in_params, 85 &ring_in_id) != 0) { 86 rte_pipeline_free(pipeline); 87 return -CHECK_TABLE_PORT_CONFIG; 88 } 89 90 /* Create table */ 91 struct rte_pipeline_table_params table_params = { 92 .ops = table_ops, 93 .arg_create = table_args, 94 .f_action_hit = NULL, 95 .f_action_miss = NULL, 96 .arg_ah = NULL, 97 .action_data_size = 0, 98 }; 99 100 if (rte_pipeline_table_create(pipeline, &table_params, 101 &table_id) != 0) { 102 rte_pipeline_free(pipeline); 103 return -CHECK_TABLE_TABLE_CONFIG; 104 } 105 106 /* Create output ports */ 107 ring_params_tx.ring = RING_TX; 108 109 struct rte_pipeline_port_out_params ring_out_params = { 110 .ops = &rte_port_ring_writer_ops, 111 .arg_create = (void *)&ring_params_tx, 112 .f_action = NULL, 113 }; 114 115 if (rte_pipeline_port_out_create(pipeline, &ring_out_params, 116 &ring_out_id) != 0) { 117 rte_pipeline_free(pipeline); 118 return -CHECK_TABLE_PORT_CONFIG; 119 } 120 121 ring_params_tx.ring = RING_TX_2; 122 123 if (rte_pipeline_port_out_create(pipeline, &ring_out_params, 124 &ring_out_2_id) != 0) { 125 rte_pipeline_free(pipeline); 126 return -CHECK_TABLE_PORT_CONFIG; 127 } 128 129 /* Add entry to the table */ 130 struct rte_pipeline_table_entry default_entry = { 131 .action = RTE_PIPELINE_ACTION_DROP, 132 {.table_id = ring_out_id}, 133 }; 134 135 struct rte_pipeline_table_entry table_entry = { 136 .action = RTE_PIPELINE_ACTION_PORT, 137 {.table_id = ring_out_id}, 138 }; 139 140 struct rte_pipeline_table_entry *default_entry_ptr, *entry_ptr; 141 142 int key_found; 143 144 if (rte_pipeline_table_default_entry_add(pipeline, table_id, 145 &default_entry, &default_entry_ptr) != 0) { 146 rte_pipeline_free(pipeline); 147 return -CHECK_TABLE_DEFAULT_ENTRY_ADD; 148 } 149 150 if (rte_pipeline_table_entry_add(pipeline, table_id, 151 key ? key : &table_entry, &table_entry, &key_found, 152 &entry_ptr) != 0) { 153 rte_pipeline_free(pipeline); 154 return -CHECK_TABLE_ENTRY_ADD; 155 } 156 157 /* Create connections and check consistency */ 158 if (rte_pipeline_port_in_connect_to_table(pipeline, ring_in_id, 159 table_id) != 0) { 160 rte_pipeline_free(pipeline); 161 return -CHECK_TABLE_CONNECT; 162 } 163 164 if (rte_pipeline_port_in_enable(pipeline, ring_in_id) != 0) { 165 rte_pipeline_free(pipeline); 166 return -CHECK_TABLE_PORT_ENABLE; 167 } 168 169 if (rte_pipeline_check(pipeline) != 0) { 170 rte_pipeline_free(pipeline); 171 return -CHECK_TABLE_CONSISTENCY; 172 } 173 174 175 176 /* Flow test - All hits */ 177 if (table_packets->n_hit_packets) { 178 for (i = 0; i < table_packets->n_hit_packets; i++) 179 RING_ENQUEUE(RING_RX, table_packets->hit_packet[i]); 180 181 RUN_PIPELINE(pipeline); 182 183 VERIFY_TRAFFIC(RING_TX, table_packets->n_hit_packets, 184 table_packets->n_hit_packets); 185 } 186 187 /* Flow test - All misses */ 188 if (table_packets->n_miss_packets) { 189 for (i = 0; i < table_packets->n_miss_packets; i++) 190 RING_ENQUEUE(RING_RX, table_packets->miss_packet[i]); 191 192 RUN_PIPELINE(pipeline); 193 194 VERIFY_TRAFFIC(RING_TX, table_packets->n_miss_packets, 0); 195 } 196 197 /* Flow test - Half hits, half misses */ 198 if (table_packets->n_hit_packets && table_packets->n_miss_packets) { 199 for (i = 0; i < (table_packets->n_hit_packets) / 2; i++) 200 RING_ENQUEUE(RING_RX, table_packets->hit_packet[i]); 201 202 for (i = 0; i < (table_packets->n_miss_packets) / 2; i++) 203 RING_ENQUEUE(RING_RX, table_packets->miss_packet[i]); 204 205 RUN_PIPELINE(pipeline); 206 VERIFY_TRAFFIC(RING_TX, table_packets->n_hit_packets, 207 table_packets->n_hit_packets / 2); 208 } 209 210 /* Flow test - Single packet */ 211 if (table_packets->n_hit_packets) { 212 RING_ENQUEUE(RING_RX, table_packets->hit_packet[0]); 213 RUN_PIPELINE(pipeline); 214 VERIFY_TRAFFIC(RING_TX, table_packets->n_hit_packets, 1); 215 } 216 if (table_packets->n_miss_packets) { 217 RING_ENQUEUE(RING_RX, table_packets->miss_packet[0]); 218 RUN_PIPELINE(pipeline); 219 VERIFY_TRAFFIC(RING_TX, table_packets->n_miss_packets, 0); 220 } 221 222 223 /* Change table entry action */ 224 printf("Change entry action\n"); 225 table_entry.table_id = ring_out_2_id; 226 227 if (rte_pipeline_table_default_entry_add(pipeline, table_id, 228 &default_entry, &default_entry_ptr) != 0) { 229 rte_pipeline_free(pipeline); 230 return -CHECK_TABLE_ENTRY_ADD; 231 } 232 233 if (rte_pipeline_table_entry_add(pipeline, table_id, 234 key ? key : &table_entry, &table_entry, &key_found, 235 &entry_ptr) != 0) { 236 rte_pipeline_free(pipeline); 237 return -CHECK_TABLE_ENTRY_ADD; 238 } 239 240 /* Check that traffic destination has changed */ 241 if (table_packets->n_hit_packets) { 242 for (i = 0; i < table_packets->n_hit_packets; i++) 243 RING_ENQUEUE(RING_RX, table_packets->hit_packet[i]); 244 245 RUN_PIPELINE(pipeline); 246 VERIFY_TRAFFIC(RING_TX, table_packets->n_hit_packets, 0); 247 VERIFY_TRAFFIC(RING_TX_2, table_packets->n_hit_packets, 248 table_packets->n_hit_packets); 249 } 250 251 printf("delete entry\n"); 252 /* Delete table entry */ 253 rte_pipeline_table_entry_delete(pipeline, table_id, 254 key ? key : &table_entry, &key_found, NULL); 255 256 rte_pipeline_free(pipeline); 257 258 return 0; 259 } 260 261 /* Table tests */ 262 int 263 test_table_stub_combined(void) 264 { 265 int status, i; 266 struct table_packets table_packets; 267 268 printf("--------------\n"); 269 printf("RUNNING TEST - %s\n", __func__); 270 printf("--------------\n"); 271 for (i = 0; i < N_PACKETS; i++) 272 table_packets.hit_packet[i] = i; 273 274 table_packets.n_hit_packets = N_PACKETS; 275 table_packets.n_miss_packets = 0; 276 277 status = test_table_type(&rte_table_stub_ops, NULL, NULL, 278 &table_packets, NULL, 1); 279 VERIFY(status, CHECK_TABLE_OK); 280 281 return 0; 282 } 283 284 int 285 test_table_lpm_combined(void) 286 { 287 int status, i; 288 289 /* Traffic flow */ 290 struct rte_table_lpm_params lpm_params = { 291 .name = "LPM", 292 .n_rules = 1 << 16, 293 .number_tbl8s = 1 << 8, 294 .flags = 0, 295 .entry_unique_size = 8, 296 .offset = APP_METADATA_OFFSET(0), 297 }; 298 299 struct rte_table_lpm_key lpm_key = { 300 .ip = 0xadadadad, 301 .depth = 16, 302 }; 303 304 struct table_packets table_packets; 305 306 printf("--------------\n"); 307 printf("RUNNING TEST - %s\n", __func__); 308 printf("--------------\n"); 309 310 for (i = 0; i < N_PACKETS; i++) 311 table_packets.hit_packet[i] = 0xadadadad; 312 313 for (i = 0; i < N_PACKETS; i++) 314 table_packets.miss_packet[i] = 0xfefefefe; 315 316 table_packets.n_hit_packets = N_PACKETS; 317 table_packets.n_miss_packets = N_PACKETS; 318 319 status = test_table_type(&rte_table_lpm_ops, (void *)&lpm_params, 320 (void *)&lpm_key, &table_packets, NULL, 0); 321 VERIFY(status, CHECK_TABLE_OK); 322 323 /* Invalid parameters */ 324 lpm_params.n_rules = 0; 325 326 status = test_table_type(&rte_table_lpm_ops, (void *)&lpm_params, 327 (void *)&lpm_key, &table_packets, NULL, 0); 328 VERIFY(status, CHECK_TABLE_TABLE_CONFIG); 329 330 lpm_params.n_rules = 1 << 24; 331 lpm_key.depth = 0; 332 333 status = test_table_type(&rte_table_lpm_ops, (void *)&lpm_params, 334 (void *)&lpm_key, &table_packets, NULL, 0); 335 VERIFY(status, CHECK_TABLE_ENTRY_ADD); 336 337 lpm_key.depth = 33; 338 339 status = test_table_type(&rte_table_lpm_ops, (void *)&lpm_params, 340 (void *)&lpm_key, &table_packets, NULL, 0); 341 VERIFY(status, CHECK_TABLE_ENTRY_ADD); 342 343 return 0; 344 } 345 346 int 347 test_table_lpm_ipv6_combined(void) 348 { 349 int status, i; 350 351 /* Traffic flow */ 352 struct rte_table_lpm_ipv6_params lpm_ipv6_params = { 353 .name = "LPM", 354 .n_rules = 1 << 16, 355 .number_tbl8s = 1 << 13, 356 .entry_unique_size = 8, 357 .offset = APP_METADATA_OFFSET(32), 358 }; 359 360 struct rte_table_lpm_ipv6_key lpm_ipv6_key = { 361 .depth = 16, 362 }; 363 memset(lpm_ipv6_key.ip, 0xad, 16); 364 365 struct table_packets table_packets; 366 367 printf("--------------\n"); 368 printf("RUNNING TEST - %s\n", __func__); 369 printf("--------------\n"); 370 for (i = 0; i < N_PACKETS; i++) 371 table_packets.hit_packet[i] = 0xadadadad; 372 373 for (i = 0; i < N_PACKETS; i++) 374 table_packets.miss_packet[i] = 0xadadadab; 375 376 table_packets.n_hit_packets = N_PACKETS; 377 table_packets.n_miss_packets = N_PACKETS; 378 379 status = test_table_type(&rte_table_lpm_ipv6_ops, 380 (void *)&lpm_ipv6_params, 381 (void *)&lpm_ipv6_key, &table_packets, NULL, 0); 382 VERIFY(status, CHECK_TABLE_OK); 383 384 /* Invalid parameters */ 385 lpm_ipv6_params.n_rules = 0; 386 387 status = test_table_type(&rte_table_lpm_ipv6_ops, 388 (void *)&lpm_ipv6_params, 389 (void *)&lpm_ipv6_key, &table_packets, NULL, 0); 390 VERIFY(status, CHECK_TABLE_TABLE_CONFIG); 391 392 lpm_ipv6_params.n_rules = 1 << 24; 393 lpm_ipv6_key.depth = 0; 394 395 status = test_table_type(&rte_table_lpm_ipv6_ops, 396 (void *)&lpm_ipv6_params, 397 (void *)&lpm_ipv6_key, &table_packets, NULL, 0); 398 VERIFY(status, CHECK_TABLE_ENTRY_ADD); 399 400 lpm_ipv6_key.depth = 129; 401 status = test_table_type(&rte_table_lpm_ipv6_ops, 402 (void *)&lpm_ipv6_params, 403 (void *)&lpm_ipv6_key, &table_packets, NULL, 0); 404 VERIFY(status, CHECK_TABLE_ENTRY_ADD); 405 406 return 0; 407 } 408 409 int 410 test_table_hash8lru(void) 411 { 412 int status, i; 413 414 /* Traffic flow */ 415 struct rte_table_hash_params key8lru_params = { 416 .name = "TABLE", 417 .key_size = 8, 418 .key_offset = APP_METADATA_OFFSET(32), 419 .key_mask = NULL, 420 .n_keys = 1 << 16, 421 .n_buckets = 1 << 16, 422 .f_hash = pipeline_test_hash, 423 .seed = 0, 424 }; 425 426 uint8_t key8lru[8]; 427 uint32_t *k8lru = (uint32_t *) key8lru; 428 429 memset(key8lru, 0, sizeof(key8lru)); 430 k8lru[0] = 0xadadadad; 431 432 struct table_packets table_packets; 433 434 printf("--------------\n"); 435 printf("RUNNING TEST - %s\n", __func__); 436 printf("--------------\n"); 437 for (i = 0; i < 50; i++) 438 table_packets.hit_packet[i] = 0xadadadad; 439 440 for (i = 0; i < 50; i++) 441 table_packets.miss_packet[i] = 0xfefefefe; 442 443 table_packets.n_hit_packets = 50; 444 table_packets.n_miss_packets = 50; 445 446 status = test_table_type(&rte_table_hash_key8_lru_ops, 447 (void *)&key8lru_params, (void *)key8lru, &table_packets, 448 NULL, 0); 449 VERIFY(status, CHECK_TABLE_OK); 450 451 /* Invalid parameters */ 452 key8lru_params.n_keys = 0; 453 454 status = test_table_type(&rte_table_hash_key8_lru_ops, 455 (void *)&key8lru_params, (void *)key8lru, &table_packets, 456 NULL, 0); 457 VERIFY(status, CHECK_TABLE_TABLE_CONFIG); 458 459 key8lru_params.n_keys = 1<<16; 460 key8lru_params.f_hash = NULL; 461 462 status = test_table_type(&rte_table_hash_key8_lru_ops, 463 (void *)&key8lru_params, (void *)key8lru, &table_packets, 464 NULL, 0); 465 VERIFY(status, CHECK_TABLE_TABLE_CONFIG); 466 467 return 0; 468 } 469 470 int 471 test_table_hash16lru(void) 472 { 473 int status, i; 474 475 /* Traffic flow */ 476 struct rte_table_hash_params key16lru_params = { 477 .name = "TABLE", 478 .key_size = 16, 479 .key_offset = APP_METADATA_OFFSET(32), 480 .key_mask = NULL, 481 .n_keys = 1 << 16, 482 .n_buckets = 1 << 16, 483 .f_hash = pipeline_test_hash, 484 .seed = 0, 485 }; 486 487 uint8_t key16lru[16]; 488 uint32_t *k16lru = (uint32_t *) key16lru; 489 490 memset(key16lru, 0, sizeof(key16lru)); 491 k16lru[0] = 0xadadadad; 492 493 struct table_packets table_packets; 494 495 printf("--------------\n"); 496 printf("RUNNING TEST - %s\n", __func__); 497 printf("--------------\n"); 498 for (i = 0; i < 50; i++) 499 table_packets.hit_packet[i] = 0xadadadad; 500 501 for (i = 0; i < 50; i++) 502 table_packets.miss_packet[i] = 0xfefefefe; 503 504 table_packets.n_hit_packets = 50; 505 table_packets.n_miss_packets = 50; 506 507 status = test_table_type(&rte_table_hash_key16_lru_ops, 508 (void *)&key16lru_params, (void *)key16lru, &table_packets, 509 NULL, 0); 510 VERIFY(status, CHECK_TABLE_OK); 511 512 /* Invalid parameters */ 513 key16lru_params.n_keys = 0; 514 515 status = test_table_type(&rte_table_hash_key16_lru_ops, 516 (void *)&key16lru_params, (void *)key16lru, &table_packets, 517 NULL, 0); 518 VERIFY(status, CHECK_TABLE_TABLE_CONFIG); 519 520 key16lru_params.n_keys = 1<<16; 521 key16lru_params.f_hash = NULL; 522 523 status = test_table_type(&rte_table_hash_key16_lru_ops, 524 (void *)&key16lru_params, (void *)key16lru, &table_packets, 525 NULL, 0); 526 VERIFY(status, CHECK_TABLE_TABLE_CONFIG); 527 528 return 0; 529 } 530 531 int 532 test_table_hash32lru(void) 533 { 534 int status, i; 535 536 /* Traffic flow */ 537 struct rte_table_hash_params key32lru_params = { 538 .name = "TABLE", 539 .key_size = 32, 540 .key_offset = APP_METADATA_OFFSET(32), 541 .key_mask = NULL, 542 .n_keys = 1 << 16, 543 .n_buckets = 1 << 16, 544 .f_hash = pipeline_test_hash, 545 .seed = 0, 546 }; 547 548 uint8_t key32lru[32]; 549 uint32_t *k32lru = (uint32_t *) key32lru; 550 551 memset(key32lru, 0, sizeof(key32lru)); 552 k32lru[0] = 0xadadadad; 553 554 struct table_packets table_packets; 555 556 printf("--------------\n"); 557 printf("RUNNING TEST - %s\n", __func__); 558 printf("--------------\n"); 559 for (i = 0; i < 50; i++) 560 table_packets.hit_packet[i] = 0xadadadad; 561 562 for (i = 0; i < 50; i++) 563 table_packets.miss_packet[i] = 0xbdadadad; 564 565 table_packets.n_hit_packets = 50; 566 table_packets.n_miss_packets = 50; 567 568 status = test_table_type(&rte_table_hash_key32_lru_ops, 569 (void *)&key32lru_params, (void *)key32lru, &table_packets, 570 NULL, 0); 571 VERIFY(status, CHECK_TABLE_OK); 572 573 /* Invalid parameters */ 574 key32lru_params.n_keys = 0; 575 576 status = test_table_type(&rte_table_hash_key32_lru_ops, 577 (void *)&key32lru_params, (void *)key32lru, &table_packets, 578 NULL, 0); 579 VERIFY(status, CHECK_TABLE_TABLE_CONFIG); 580 581 key32lru_params.n_keys = 1<<16; 582 key32lru_params.f_hash = NULL; 583 584 status = test_table_type(&rte_table_hash_key32_lru_ops, 585 (void *)&key32lru_params, (void *)key32lru, &table_packets, 586 NULL, 0); 587 VERIFY(status, CHECK_TABLE_TABLE_CONFIG); 588 589 return 0; 590 } 591 592 int 593 test_table_hash8ext(void) 594 { 595 int status, i; 596 597 /* Traffic flow */ 598 struct rte_table_hash_params key8ext_params = { 599 .name = "TABLE", 600 .key_size = 8, 601 .key_offset = APP_METADATA_OFFSET(32), 602 .key_mask = NULL, 603 .n_keys = 1 << 16, 604 .n_buckets = 1 << 16, 605 .f_hash = pipeline_test_hash, 606 .seed = 0, 607 }; 608 609 uint8_t key8ext[8]; 610 uint32_t *k8ext = (uint32_t *) key8ext; 611 612 memset(key8ext, 0, sizeof(key8ext)); 613 k8ext[0] = 0xadadadad; 614 615 struct table_packets table_packets; 616 617 printf("--------------\n"); 618 printf("RUNNING TEST - %s\n", __func__); 619 printf("--------------\n"); 620 for (i = 0; i < 50; i++) 621 table_packets.hit_packet[i] = 0xadadadad; 622 623 for (i = 0; i < 50; i++) 624 table_packets.miss_packet[i] = 0xbdadadad; 625 626 table_packets.n_hit_packets = 50; 627 table_packets.n_miss_packets = 50; 628 629 status = test_table_type(&rte_table_hash_key8_ext_ops, 630 (void *)&key8ext_params, (void *)key8ext, &table_packets, 631 NULL, 0); 632 VERIFY(status, CHECK_TABLE_OK); 633 634 /* Invalid parameters */ 635 key8ext_params.n_keys = 0; 636 637 status = test_table_type(&rte_table_hash_key8_ext_ops, 638 (void *)&key8ext_params, (void *)key8ext, &table_packets, 639 NULL, 0); 640 VERIFY(status, CHECK_TABLE_TABLE_CONFIG); 641 642 key8ext_params.n_keys = 1<<16; 643 key8ext_params.f_hash = NULL; 644 645 status = test_table_type(&rte_table_hash_key8_ext_ops, 646 (void *)&key8ext_params, (void *)key8ext, &table_packets, 647 NULL, 0); 648 VERIFY(status, CHECK_TABLE_TABLE_CONFIG); 649 650 return 0; 651 } 652 653 int 654 test_table_hash16ext(void) 655 { 656 int status, i; 657 658 /* Traffic flow */ 659 struct rte_table_hash_params key16ext_params = { 660 .name = "TABLE", 661 .key_size = 16, 662 .key_offset = APP_METADATA_OFFSET(32), 663 .key_mask = NULL, 664 .n_keys = 1 << 16, 665 .n_buckets = 1 << 16, 666 .f_hash = pipeline_test_hash, 667 .seed = 0, 668 }; 669 670 uint8_t key16ext[16]; 671 uint32_t *k16ext = (uint32_t *) key16ext; 672 673 memset(key16ext, 0, sizeof(key16ext)); 674 k16ext[0] = 0xadadadad; 675 676 struct table_packets table_packets; 677 678 printf("--------------\n"); 679 printf("RUNNING TEST - %s\n", __func__); 680 printf("--------------\n"); 681 for (i = 0; i < 50; i++) 682 table_packets.hit_packet[i] = 0xadadadad; 683 684 for (i = 0; i < 50; i++) 685 table_packets.miss_packet[i] = 0xbdadadad; 686 687 table_packets.n_hit_packets = 50; 688 table_packets.n_miss_packets = 50; 689 690 status = test_table_type(&rte_table_hash_key16_ext_ops, 691 (void *)&key16ext_params, (void *)key16ext, &table_packets, 692 NULL, 0); 693 VERIFY(status, CHECK_TABLE_OK); 694 695 /* Invalid parameters */ 696 key16ext_params.n_keys = 0; 697 698 status = test_table_type(&rte_table_hash_key16_ext_ops, 699 (void *)&key16ext_params, (void *)key16ext, &table_packets, 700 NULL, 0); 701 VERIFY(status, CHECK_TABLE_TABLE_CONFIG); 702 703 key16ext_params.n_keys = 1<<16; 704 key16ext_params.f_hash = NULL; 705 706 status = test_table_type(&rte_table_hash_key16_ext_ops, 707 (void *)&key16ext_params, (void *)key16ext, &table_packets, 708 NULL, 0); 709 VERIFY(status, CHECK_TABLE_TABLE_CONFIG); 710 711 return 0; 712 } 713 714 int 715 test_table_hash32ext(void) 716 { 717 int status, i; 718 719 /* Traffic flow */ 720 struct rte_table_hash_params key32ext_params = { 721 .name = "TABLE", 722 .key_size = 32, 723 .key_offset = APP_METADATA_OFFSET(32), 724 .key_mask = NULL, 725 .n_keys = 1 << 16, 726 .n_buckets = 1 << 16, 727 .f_hash = pipeline_test_hash, 728 .seed = 0, 729 }; 730 731 uint8_t key32ext[32]; 732 uint32_t *k32ext = (uint32_t *) key32ext; 733 734 memset(key32ext, 0, sizeof(key32ext)); 735 k32ext[0] = 0xadadadad; 736 737 struct table_packets table_packets; 738 739 printf("--------------\n"); 740 printf("RUNNING TEST - %s\n", __func__); 741 printf("--------------\n"); 742 for (i = 0; i < 50; i++) 743 table_packets.hit_packet[i] = 0xadadadad; 744 745 for (i = 0; i < 50; i++) 746 table_packets.miss_packet[i] = 0xbdadadad; 747 748 table_packets.n_hit_packets = 50; 749 table_packets.n_miss_packets = 50; 750 751 status = test_table_type(&rte_table_hash_key32_ext_ops, 752 (void *)&key32ext_params, (void *)key32ext, &table_packets, 753 NULL, 0); 754 VERIFY(status, CHECK_TABLE_OK); 755 756 /* Invalid parameters */ 757 key32ext_params.n_keys = 0; 758 759 status = test_table_type(&rte_table_hash_key32_ext_ops, 760 (void *)&key32ext_params, (void *)key32ext, &table_packets, 761 NULL, 0); 762 VERIFY(status, CHECK_TABLE_TABLE_CONFIG); 763 764 key32ext_params.n_keys = 1<<16; 765 key32ext_params.f_hash = NULL; 766 767 status = test_table_type(&rte_table_hash_key32_ext_ops, 768 (void *)&key32ext_params, (void *)key32ext, &table_packets, 769 NULL, 0); 770 VERIFY(status, CHECK_TABLE_TABLE_CONFIG); 771 772 return 0; 773 } 774 775 int 776 test_table_hash_cuckoo_combined(void) 777 { 778 int status, i; 779 780 /* Traffic flow */ 781 struct rte_table_hash_cuckoo_params cuckoo_params = { 782 .name = "TABLE", 783 .key_size = 32, 784 .key_offset = APP_METADATA_OFFSET(32), 785 .key_mask = NULL, 786 .n_keys = 1 << 16, 787 .n_buckets = 1 << 16, 788 .f_hash = pipeline_test_hash_cuckoo, 789 .seed = 0, 790 }; 791 792 uint8_t key_cuckoo[32]; 793 uint32_t *kcuckoo = (uint32_t *) key_cuckoo; 794 795 memset(key_cuckoo, 0, sizeof(key_cuckoo)); 796 kcuckoo[0] = 0xadadadad; 797 798 struct table_packets table_packets; 799 800 printf("--------------\n"); 801 printf("RUNNING TEST - %s\n", __func__); 802 printf("--------------\n"); 803 for (i = 0; i < 50; i++) 804 table_packets.hit_packet[i] = 0xadadadad; 805 806 for (i = 0; i < 50; i++) 807 table_packets.miss_packet[i] = 0xbdadadad; 808 809 table_packets.n_hit_packets = 50; 810 table_packets.n_miss_packets = 50; 811 812 status = test_table_type(&rte_table_hash_cuckoo_ops, 813 (void *)&cuckoo_params, (void *)key_cuckoo, &table_packets, 814 NULL, 0); 815 VERIFY(status, CHECK_TABLE_OK); 816 817 /* Invalid parameters */ 818 cuckoo_params.key_size = 0; 819 820 status = test_table_type(&rte_table_hash_cuckoo_ops, 821 (void *)&cuckoo_params, (void *)key_cuckoo, &table_packets, 822 NULL, 0); 823 VERIFY(status, CHECK_TABLE_TABLE_CONFIG); 824 825 cuckoo_params.key_size = 32; 826 cuckoo_params.n_keys = 0; 827 828 status = test_table_type(&rte_table_hash_cuckoo_ops, 829 (void *)&cuckoo_params, (void *)key_cuckoo, &table_packets, 830 NULL, 0); 831 VERIFY(status, CHECK_TABLE_TABLE_CONFIG); 832 833 cuckoo_params.n_keys = 1<<16; 834 cuckoo_params.f_hash = NULL; 835 836 status = test_table_type(&rte_table_hash_cuckoo_ops, 837 (void *)&cuckoo_params, (void *)key_cuckoo, &table_packets, 838 NULL, 0); 839 VERIFY(status, CHECK_TABLE_TABLE_CONFIG); 840 841 return 0; 842 } 843