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