net/virtio: fix incorrect cast of void *
[dpdk.git] / 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