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 = (rte_table_hash_op_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 = (rte_table_hash_op_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_key32_lru_params key32lru_params = {
 567                 .n_entries = 1<<16,
 568                 .f_hash = pipeline_test_hash,
 569                 .seed = 0,
 570                 .signature_offset = APP_METADATA_OFFSET(0),
 571                 .key_offset = APP_METADATA_OFFSET(32),
 572         };
 573
 574         uint8_t key32lru[32];
 575         uint32_t *k32lru = (uint32_t *) key32lru;
 576
 577         memset(key32lru, 0, sizeof(key32lru));
 578         k32lru[0] = 0xadadadad;
 579
 580         struct table_packets table_packets;
 581
 582         printf("--------------\n");
 583         printf("RUNNING TEST - %s\n", __func__);
 584         printf("--------------\n");
 585         for (i = 0; i < 50; i++)
 586                 table_packets.hit_packet[i] = 0xadadadad;
 587
 588         for (i = 0; i < 50; i++)
 589                 table_packets.miss_packet[i] = 0xbdadadad;
 590
 591         table_packets.n_hit_packets = 50;
 592         table_packets.n_miss_packets = 50;
 593
 594         status = test_table_type(&rte_table_hash_key32_lru_ops,
 595                 (void *)&key32lru_params, (void *)key32lru, &table_packets,
 596                 NULL, 0);
 597         VERIFY(status, CHECK_TABLE_OK);
 598
 599         /* Invalid parameters */
 600         key32lru_params.n_entries = 0;
 601
 602         status = test_table_type(&rte_table_hash_key32_lru_ops,
 603                 (void *)&key32lru_params, (void *)key32lru, &table_packets,
 604                 NULL, 0);
 605         VERIFY(status, CHECK_TABLE_TABLE_CONFIG);
 606
 607         key32lru_params.n_entries = 1<<16;
 608         key32lru_params.f_hash = NULL;
 609
 610         status = test_table_type(&rte_table_hash_key32_lru_ops,
 611                 (void *)&key32lru_params, (void *)key32lru, &table_packets,
 612                 NULL, 0);
 613         VERIFY(status, CHECK_TABLE_TABLE_CONFIG);
 614
 615         return 0;
 616 }
 617
 618 int
 619 test_table_hash8ext(void)
 620 {
 621         int status, i;
 622
 623         /* Traffic flow */
 624         struct rte_table_hash_params key8ext_params = {
 625                 .name = "TABLE",
 626                 .key_size = 8,
 627                 .key_offset = APP_METADATA_OFFSET(32),
 628                 .key_mask = NULL,
 629                 .n_keys = 1 << 16,
 630                 .n_buckets = 1 << 16,
 631                 .f_hash = (rte_table_hash_op_hash)pipeline_test_hash,
 632                 .seed = 0,
 633         };
 634
 635         uint8_t key8ext[8];
 636         uint32_t *k8ext = (uint32_t *) key8ext;
 637
 638         memset(key8ext, 0, sizeof(key8ext));
 639         k8ext[0] = 0xadadadad;
 640
 641         struct table_packets table_packets;
 642
 643         printf("--------------\n");
 644         printf("RUNNING TEST - %s\n", __func__);
 645         printf("--------------\n");
 646         for (i = 0; i < 50; i++)
 647                 table_packets.hit_packet[i] = 0xadadadad;
 648
 649         for (i = 0; i < 50; i++)
 650                 table_packets.miss_packet[i] = 0xbdadadad;
 651
 652         table_packets.n_hit_packets = 50;
 653         table_packets.n_miss_packets = 50;
 654
 655         status = test_table_type(&rte_table_hash_key8_ext_ops,
 656                 (void *)&key8ext_params, (void *)key8ext, &table_packets,
 657                 NULL, 0);
 658         VERIFY(status, CHECK_TABLE_OK);
 659
 660         /* Invalid parameters */
 661         key8ext_params.n_keys = 0;
 662
 663         status = test_table_type(&rte_table_hash_key8_ext_ops,
 664                 (void *)&key8ext_params, (void *)key8ext, &table_packets,
 665                 NULL, 0);
 666         VERIFY(status, CHECK_TABLE_TABLE_CONFIG);
 667
 668         key8ext_params.n_keys = 1<<16;
 669         key8ext_params.f_hash = NULL;
 670
 671         status = test_table_type(&rte_table_hash_key8_ext_ops,
 672                 (void *)&key8ext_params, (void *)key8ext, &table_packets,
 673                 NULL, 0);
 674         VERIFY(status, CHECK_TABLE_TABLE_CONFIG);
 675
 676         return 0;
 677 }
 678
 679 int
 680 test_table_hash16ext(void)
 681 {
 682         int status, i;
 683
 684         /* Traffic flow */
 685         struct rte_table_hash_params key16ext_params = {
 686                 .name = "TABLE",
 687                 .key_size = 16,
 688                 .key_offset = APP_METADATA_OFFSET(32),
 689                 .key_mask = NULL,
 690                 .n_keys = 1 << 16,
 691                 .n_buckets = 1 << 16,
 692                 .f_hash = (rte_table_hash_op_hash)pipeline_test_hash,
 693                 .seed = 0,
 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_keys = 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_keys = 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         return 0;
 738 }
 739
 740 int
 741 test_table_hash32ext(void)
 742 {
 743         int status, i;
 744
 745         /* Traffic flow */
 746         struct rte_table_hash_key32_ext_params key32ext_params = {
 747                 .n_entries = 1<<16,
 748                 .n_entries_ext = 1<<15,
 749                 .f_hash = pipeline_test_hash,
 750                 .seed = 0,
 751                 .signature_offset = APP_METADATA_OFFSET(0),
 752                 .key_offset = APP_METADATA_OFFSET(32),
 753         };
 754
 755         uint8_t key32ext[32];
 756         uint32_t *k32ext = (uint32_t *) key32ext;
 757
 758         memset(key32ext, 0, sizeof(key32ext));
 759         k32ext[0] = 0xadadadad;
 760
 761         struct table_packets table_packets;
 762
 763         printf("--------------\n");
 764         printf("RUNNING TEST - %s\n", __func__);
 765         printf("--------------\n");
 766         for (i = 0; i < 50; i++)
 767                 table_packets.hit_packet[i] = 0xadadadad;
 768
 769         for (i = 0; i < 50; i++)
 770                 table_packets.miss_packet[i] = 0xbdadadad;
 771
 772         table_packets.n_hit_packets = 50;
 773         table_packets.n_miss_packets = 50;
 774
 775         status = test_table_type(&rte_table_hash_key32_ext_ops,
 776                 (void *)&key32ext_params, (void *)key32ext, &table_packets,
 777                 NULL, 0);
 778         VERIFY(status, CHECK_TABLE_OK);
 779
 780         /* Invalid parameters */
 781         key32ext_params.n_entries = 0;
 782
 783         status = test_table_type(&rte_table_hash_key32_ext_ops,
 784                 (void *)&key32ext_params, (void *)key32ext, &table_packets,
 785                 NULL, 0);
 786         VERIFY(status, CHECK_TABLE_TABLE_CONFIG);
 787
 788         key32ext_params.n_entries = 1<<16;
 789         key32ext_params.f_hash = NULL;
 790
 791         status = test_table_type(&rte_table_hash_key32_ext_ops,
 792                 (void *)&key32ext_params, (void *)key32ext, &table_packets,
 793                 NULL, 0);
 794         VERIFY(status, CHECK_TABLE_TABLE_CONFIG);
 795
 796         key32ext_params.f_hash = pipeline_test_hash;
 797         key32ext_params.n_entries_ext = 0;
 798
 799         status = test_table_type(&rte_table_hash_key32_ext_ops,
 800                 (void *)&key32ext_params, (void *)key32ext, &table_packets,
 801                 NULL, 0);
 802         VERIFY(status, CHECK_TABLE_TABLE_CONFIG);
 803
 804         return 0;
 805 }
 806
 807 int
 808 test_table_hash_cuckoo_combined(void)
 809 {
 810         int status, i;
 811
 812         /* Traffic flow */
 813         struct rte_table_hash_cuckoo_params cuckoo_params = {
 814                 .key_size = 32,
 815                 .n_keys = 1<<16,
 816                 .f_hash = pipeline_test_hash,
 817                 .seed = 0,
 818                 .signature_offset = APP_METADATA_OFFSET(0),
 819                 .key_offset = APP_METADATA_OFFSET(32),
 820                 .name = "CUCKOO_HASH",
 821         };
 822
 823         uint8_t key_cuckoo[32];
 824         uint32_t *kcuckoo = (uint32_t *) key_cuckoo;
 825
 826         memset(key_cuckoo, 0, sizeof(key_cuckoo));
 827         kcuckoo[0] = 0xadadadad;
 828
 829         struct table_packets table_packets;
 830
 831         printf("--------------\n");
 832         printf("RUNNING TEST - %s\n", __func__);
 833         printf("--------------\n");
 834         for (i = 0; i < 50; i++)
 835                 table_packets.hit_packet[i] = 0xadadadad;
 836
 837         for (i = 0; i < 50; i++)
 838                 table_packets.miss_packet[i] = 0xbdadadad;
 839
 840         table_packets.n_hit_packets = 50;
 841         table_packets.n_miss_packets = 50;
 842
 843         status = test_table_type(&rte_table_hash_cuckoo_ops,
 844                 (void *)&cuckoo_params, (void *)key_cuckoo, &table_packets,
 845                 NULL, 0);
 846         VERIFY(status, CHECK_TABLE_OK);
 847
 848         /* Invalid parameters */
 849         cuckoo_params.key_size = 0;
 850
 851         status = test_table_type(&rte_table_hash_cuckoo_ops,
 852                 (void *)&cuckoo_params, (void *)key_cuckoo, &table_packets,
 853                 NULL, 0);
 854         VERIFY(status, CHECK_TABLE_TABLE_CONFIG);
 855
 856         cuckoo_params.key_size = 32;
 857         cuckoo_params.n_keys = 0;
 858
 859         status = test_table_type(&rte_table_hash_cuckoo_ops,
 860                 (void *)&cuckoo_params, (void *)key_cuckoo, &table_packets,
 861                 NULL, 0);
 862         VERIFY(status, CHECK_TABLE_TABLE_CONFIG);
 863
 864         cuckoo_params.n_keys = 1<<16;
 865         cuckoo_params.f_hash = NULL;
 866
 867         status = test_table_type(&rte_table_hash_cuckoo_ops,
 868                 (void *)&cuckoo_params, (void *)key_cuckoo, &table_packets,
 869                 NULL, 0);
 870         VERIFY(status, CHECK_TABLE_TABLE_CONFIG);
 871
 872         return 0;
 873 }
 874