app/test/test_table_combined.c

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