app/test/test_table_combined.c

   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