test/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_params key8lru_params = {
 445                 .name = "TABLE",
 446                 .key_size = 8,
 447                 .key_offset = APP_METADATA_OFFSET(32),
 448                 .key_mask = NULL,
 449                 .n_keys = 1 << 16,
 450                 .n_buckets = 1 << 16,
 451                 .f_hash = pipeline_test_hash,
 452                 .seed = 0,
 453         };
 454
 455         uint8_t key8lru[8];
 456         uint32_t *k8lru = (uint32_t *) key8lru;
 457
 458         memset(key8lru, 0, sizeof(key8lru));
 459         k8lru[0] = 0xadadadad;
 460
 461         struct table_packets table_packets;
 462
 463         printf("--------------\n");
 464         printf("RUNNING TEST - %s\n", __func__);
 465         printf("--------------\n");
 466         for (i = 0; i < 50; i++)
 467                 table_packets.hit_packet[i] = 0xadadadad;
 468
 469         for (i = 0; i < 50; i++)
 470                 table_packets.miss_packet[i] = 0xfefefefe;
 471
 472         table_packets.n_hit_packets = 50;
 473         table_packets.n_miss_packets = 50;
 474
 475         status = test_table_type(&rte_table_hash_key8_lru_ops,
 476                 (void *)&key8lru_params, (void *)key8lru, &table_packets,
 477                         NULL, 0);
 478         VERIFY(status, CHECK_TABLE_OK);
 479
 480         /* Invalid parameters */
 481         key8lru_params.n_keys = 0;
 482
 483         status = test_table_type(&rte_table_hash_key8_lru_ops,
 484                 (void *)&key8lru_params, (void *)key8lru, &table_packets,
 485                         NULL, 0);
 486         VERIFY(status, CHECK_TABLE_TABLE_CONFIG);
 487
 488         key8lru_params.n_keys = 1<<16;
 489         key8lru_params.f_hash = NULL;
 490
 491         status = test_table_type(&rte_table_hash_key8_lru_ops,
 492                 (void *)&key8lru_params, (void *)key8lru, &table_packets,
 493                         NULL, 0);
 494         VERIFY(status, CHECK_TABLE_TABLE_CONFIG);
 495
 496         return 0;
 497 }
 498
 499 int
 500 test_table_hash16lru(void)
 501 {
 502         int status, i;
 503
 504         /* Traffic flow */
 505         struct rte_table_hash_params key16lru_params = {
 506                 .name = "TABLE",
 507                 .key_size = 16,
 508                 .key_offset = APP_METADATA_OFFSET(32),
 509                 .key_mask = NULL,
 510                 .n_keys = 1 << 16,
 511                 .n_buckets = 1 << 16,
 512                 .f_hash = pipeline_test_hash,
 513                 .seed = 0,
 514         };
 515
 516         uint8_t key16lru[16];
 517         uint32_t *k16lru = (uint32_t *) key16lru;
 518
 519         memset(key16lru, 0, sizeof(key16lru));
 520         k16lru[0] = 0xadadadad;
 521
 522         struct table_packets table_packets;
 523
 524         printf("--------------\n");
 525         printf("RUNNING TEST - %s\n", __func__);
 526         printf("--------------\n");
 527         for (i = 0; i < 50; i++)
 528                 table_packets.hit_packet[i] = 0xadadadad;
 529
 530         for (i = 0; i < 50; i++)
 531                 table_packets.miss_packet[i] = 0xfefefefe;
 532
 533         table_packets.n_hit_packets = 50;
 534         table_packets.n_miss_packets = 50;
 535
 536         status = test_table_type(&rte_table_hash_key16_lru_ops,
 537                 (void *)&key16lru_params, (void *)key16lru, &table_packets,
 538                         NULL, 0);
 539         VERIFY(status, CHECK_TABLE_OK);
 540
 541         /* Invalid parameters */
 542         key16lru_params.n_keys = 0;
 543
 544         status = test_table_type(&rte_table_hash_key16_lru_ops,
 545                 (void *)&key16lru_params, (void *)key16lru, &table_packets,
 546                         NULL, 0);
 547         VERIFY(status, CHECK_TABLE_TABLE_CONFIG);
 548
 549         key16lru_params.n_keys = 1<<16;
 550         key16lru_params.f_hash = NULL;
 551
 552         status = test_table_type(&rte_table_hash_key16_lru_ops,
 553                 (void *)&key16lru_params, (void *)key16lru, &table_packets,
 554                         NULL, 0);
 555         VERIFY(status, CHECK_TABLE_TABLE_CONFIG);
 556
 557         return 0;
 558 }
 559
 560 int
 561 test_table_hash32lru(void)
 562 {
 563         int status, i;
 564
 565         /* Traffic flow */
 566         struct rte_table_hash_params key32lru_params = {
 567                 .name = "TABLE",
 568                 .key_size = 32,
 569                 .key_offset = APP_METADATA_OFFSET(32),
 570                 .key_mask = NULL,
 571                 .n_keys = 1 << 16,
 572                 .n_buckets = 1 << 16,
 573                 .f_hash = pipeline_test_hash,
 574                 .seed = 0,
 575         };
 576
 577         uint8_t key32lru[32];
 578         uint32_t *k32lru = (uint32_t *) key32lru;
 579
 580         memset(key32lru, 0, sizeof(key32lru));
 581         k32lru[0] = 0xadadadad;
 582
 583         struct table_packets table_packets;
 584
 585         printf("--------------\n");
 586         printf("RUNNING TEST - %s\n", __func__);
 587         printf("--------------\n");
 588         for (i = 0; i < 50; i++)
 589                 table_packets.hit_packet[i] = 0xadadadad;
 590
 591         for (i = 0; i < 50; i++)
 592                 table_packets.miss_packet[i] = 0xbdadadad;
 593
 594         table_packets.n_hit_packets = 50;
 595         table_packets.n_miss_packets = 50;
 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_OK);
 601
 602         /* Invalid parameters */
 603         key32lru_params.n_keys = 0;
 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         key32lru_params.n_keys = 1<<16;
 611         key32lru_params.f_hash = NULL;
 612
 613         status = test_table_type(&rte_table_hash_key32_lru_ops,
 614                 (void *)&key32lru_params, (void *)key32lru, &table_packets,
 615                 NULL, 0);
 616         VERIFY(status, CHECK_TABLE_TABLE_CONFIG);
 617
 618         return 0;
 619 }
 620
 621 int
 622 test_table_hash8ext(void)
 623 {
 624         int status, i;
 625
 626         /* Traffic flow */
 627         struct rte_table_hash_params key8ext_params = {
 628                 .name = "TABLE",
 629                 .key_size = 8,
 630                 .key_offset = APP_METADATA_OFFSET(32),
 631                 .key_mask = NULL,
 632                 .n_keys = 1 << 16,
 633                 .n_buckets = 1 << 16,
 634                 .f_hash = pipeline_test_hash,
 635                 .seed = 0,
 636         };
 637
 638         uint8_t key8ext[8];
 639         uint32_t *k8ext = (uint32_t *) key8ext;
 640
 641         memset(key8ext, 0, sizeof(key8ext));
 642         k8ext[0] = 0xadadadad;
 643
 644         struct table_packets table_packets;
 645
 646         printf("--------------\n");
 647         printf("RUNNING TEST - %s\n", __func__);
 648         printf("--------------\n");
 649         for (i = 0; i < 50; i++)
 650                 table_packets.hit_packet[i] = 0xadadadad;
 651
 652         for (i = 0; i < 50; i++)
 653                 table_packets.miss_packet[i] = 0xbdadadad;
 654
 655         table_packets.n_hit_packets = 50;
 656         table_packets.n_miss_packets = 50;
 657
 658         status = test_table_type(&rte_table_hash_key8_ext_ops,
 659                 (void *)&key8ext_params, (void *)key8ext, &table_packets,
 660                 NULL, 0);
 661         VERIFY(status, CHECK_TABLE_OK);
 662
 663         /* Invalid parameters */
 664         key8ext_params.n_keys = 0;
 665
 666         status = test_table_type(&rte_table_hash_key8_ext_ops,
 667                 (void *)&key8ext_params, (void *)key8ext, &table_packets,
 668                 NULL, 0);
 669         VERIFY(status, CHECK_TABLE_TABLE_CONFIG);
 670
 671         key8ext_params.n_keys = 1<<16;
 672         key8ext_params.f_hash = NULL;
 673
 674         status = test_table_type(&rte_table_hash_key8_ext_ops,
 675                 (void *)&key8ext_params, (void *)key8ext, &table_packets,
 676                 NULL, 0);
 677         VERIFY(status, CHECK_TABLE_TABLE_CONFIG);
 678
 679         return 0;
 680 }
 681
 682 int
 683 test_table_hash16ext(void)
 684 {
 685         int status, i;
 686
 687         /* Traffic flow */
 688         struct rte_table_hash_params key16ext_params = {
 689                 .name = "TABLE",
 690                 .key_size = 16,
 691                 .key_offset = APP_METADATA_OFFSET(32),
 692                 .key_mask = NULL,
 693                 .n_keys = 1 << 16,
 694                 .n_buckets = 1 << 16,
 695                 .f_hash = pipeline_test_hash,
 696                 .seed = 0,
 697         };
 698
 699         uint8_t key16ext[16];
 700         uint32_t *k16ext = (uint32_t *) key16ext;
 701
 702         memset(key16ext, 0, sizeof(key16ext));
 703         k16ext[0] = 0xadadadad;
 704
 705         struct table_packets table_packets;
 706
 707         printf("--------------\n");
 708         printf("RUNNING TEST - %s\n", __func__);
 709         printf("--------------\n");
 710         for (i = 0; i < 50; i++)
 711                 table_packets.hit_packet[i] = 0xadadadad;
 712
 713         for (i = 0; i < 50; i++)
 714                 table_packets.miss_packet[i] = 0xbdadadad;
 715
 716         table_packets.n_hit_packets = 50;
 717         table_packets.n_miss_packets = 50;
 718
 719         status = test_table_type(&rte_table_hash_key16_ext_ops,
 720                 (void *)&key16ext_params, (void *)key16ext, &table_packets,
 721                 NULL, 0);
 722         VERIFY(status, CHECK_TABLE_OK);
 723
 724         /* Invalid parameters */
 725         key16ext_params.n_keys = 0;
 726
 727         status = test_table_type(&rte_table_hash_key16_ext_ops,
 728                 (void *)&key16ext_params, (void *)key16ext, &table_packets,
 729                 NULL, 0);
 730         VERIFY(status, CHECK_TABLE_TABLE_CONFIG);
 731
 732         key16ext_params.n_keys = 1<<16;
 733         key16ext_params.f_hash = NULL;
 734
 735         status = test_table_type(&rte_table_hash_key16_ext_ops,
 736                 (void *)&key16ext_params, (void *)key16ext, &table_packets,
 737                 NULL, 0);
 738         VERIFY(status, CHECK_TABLE_TABLE_CONFIG);
 739
 740         return 0;
 741 }
 742
 743 int
 744 test_table_hash32ext(void)
 745 {
 746         int status, i;
 747
 748         /* Traffic flow */
 749         struct rte_table_hash_params key32ext_params = {
 750                 .name = "TABLE",
 751                 .key_size = 32,
 752                 .key_offset = APP_METADATA_OFFSET(32),
 753                 .key_mask = NULL,
 754                 .n_keys = 1 << 16,
 755                 .n_buckets = 1 << 16,
 756                 .f_hash = pipeline_test_hash,
 757                 .seed = 0,
 758         };
 759
 760         uint8_t key32ext[32];
 761         uint32_t *k32ext = (uint32_t *) key32ext;
 762
 763         memset(key32ext, 0, sizeof(key32ext));
 764         k32ext[0] = 0xadadadad;
 765
 766         struct table_packets table_packets;
 767
 768         printf("--------------\n");
 769         printf("RUNNING TEST - %s\n", __func__);
 770         printf("--------------\n");
 771         for (i = 0; i < 50; i++)
 772                 table_packets.hit_packet[i] = 0xadadadad;
 773
 774         for (i = 0; i < 50; i++)
 775                 table_packets.miss_packet[i] = 0xbdadadad;
 776
 777         table_packets.n_hit_packets = 50;
 778         table_packets.n_miss_packets = 50;
 779
 780         status = test_table_type(&rte_table_hash_key32_ext_ops,
 781                 (void *)&key32ext_params, (void *)key32ext, &table_packets,
 782                 NULL, 0);
 783         VERIFY(status, CHECK_TABLE_OK);
 784
 785         /* Invalid parameters */
 786         key32ext_params.n_keys = 0;
 787
 788         status = test_table_type(&rte_table_hash_key32_ext_ops,
 789                 (void *)&key32ext_params, (void *)key32ext, &table_packets,
 790                 NULL, 0);
 791         VERIFY(status, CHECK_TABLE_TABLE_CONFIG);
 792
 793         key32ext_params.n_keys = 1<<16;
 794         key32ext_params.f_hash = NULL;
 795
 796         status = test_table_type(&rte_table_hash_key32_ext_ops,
 797                 (void *)&key32ext_params, (void *)key32ext, &table_packets,
 798                 NULL, 0);
 799         VERIFY(status, CHECK_TABLE_TABLE_CONFIG);
 800
 801         return 0;
 802 }
 803
 804 int
 805 test_table_hash_cuckoo_combined(void)
 806 {
 807         int status, i;
 808
 809         /* Traffic flow */
 810         struct rte_table_hash_params cuckoo_params = {
 811                 .name = "TABLE",
 812                 .key_size = 32,
 813                 .key_offset = APP_METADATA_OFFSET(32),
 814                 .key_mask = NULL,
 815                 .n_keys = 1 << 16,
 816                 .n_buckets = 1 << 16,
 817                 .f_hash = pipeline_test_hash,
 818                 .seed = 0,
 819         };
 820
 821         uint8_t key_cuckoo[32];
 822         uint32_t *kcuckoo = (uint32_t *) key_cuckoo;
 823
 824         memset(key_cuckoo, 0, sizeof(key_cuckoo));
 825         kcuckoo[0] = 0xadadadad;
 826
 827         struct table_packets table_packets;
 828
 829         printf("--------------\n");
 830         printf("RUNNING TEST - %s\n", __func__);
 831         printf("--------------\n");
 832         for (i = 0; i < 50; i++)
 833                 table_packets.hit_packet[i] = 0xadadadad;
 834
 835         for (i = 0; i < 50; i++)
 836                 table_packets.miss_packet[i] = 0xbdadadad;
 837
 838         table_packets.n_hit_packets = 50;
 839         table_packets.n_miss_packets = 50;
 840
 841         status = test_table_type(&rte_table_hash_cuckoo_ops,
 842                 (void *)&cuckoo_params, (void *)key_cuckoo, &table_packets,
 843                 NULL, 0);
 844         VERIFY(status, CHECK_TABLE_OK);
 845
 846         /* Invalid parameters */
 847         cuckoo_params.key_size = 0;
 848
 849         status = test_table_type(&rte_table_hash_cuckoo_ops,
 850                 (void *)&cuckoo_params, (void *)key_cuckoo, &table_packets,
 851                 NULL, 0);
 852         VERIFY(status, CHECK_TABLE_TABLE_CONFIG);
 853
 854         cuckoo_params.key_size = 32;
 855         cuckoo_params.n_keys = 0;
 856
 857         status = test_table_type(&rte_table_hash_cuckoo_ops,
 858                 (void *)&cuckoo_params, (void *)key_cuckoo, &table_packets,
 859                 NULL, 0);
 860         VERIFY(status, CHECK_TABLE_TABLE_CONFIG);
 861
 862         cuckoo_params.n_keys = 1<<16;
 863         cuckoo_params.f_hash = NULL;
 864
 865         status = test_table_type(&rte_table_hash_cuckoo_ops,
 866                 (void *)&cuckoo_params, (void *)key_cuckoo, &table_packets,
 867                 NULL, 0);
 868         VERIFY(status, CHECK_TABLE_TABLE_CONFIG);
 869
 870         return 0;
 871 }
 872