net/ice: fix perfect match for ACL rule
[dpdk.git] / app / test / test_graph_perf.c
1 /* SPDX-License-Identifier: BSD-3-Clause
2  * Copyright(C) 2020 Marvell International Ltd.
3  */
4 #include <inttypes.h>
5 #include <signal.h>
6 #include <stdio.h>
7 #include <unistd.h>
8
9 #include <rte_common.h>
10 #include <rte_cycles.h>
11 #include <rte_errno.h>
12 #include <rte_graph.h>
13 #include <rte_graph_worker.h>
14 #include <rte_lcore.h>
15 #include <rte_malloc.h>
16 #include <rte_mbuf.h>
17
18 #include "test.h"
19
20 #define TEST_GRAPH_PERF_MZ           "graph_perf_data"
21 #define TEST_GRAPH_SRC_NAME          "test_graph_perf_source"
22 #define TEST_GRAPH_SRC_BRST_ONE_NAME "test_graph_perf_source_one"
23 #define TEST_GRAPH_WRK_NAME          "test_graph_perf_worker"
24 #define TEST_GRAPH_SNK_NAME          "test_graph_perf_sink"
25
26 #define SOURCES(map)         RTE_DIM(map)
27 #define STAGES(map)          RTE_DIM(map)
28 #define NODES_PER_STAGE(map) RTE_DIM(map[0])
29 #define SINKS(map)           RTE_DIM(map[0])
30
31 #define MAX_EDGES_PER_NODE 7
32
33 struct test_node_data {
34         uint8_t node_id;
35         uint8_t is_sink;
36         uint8_t next_nodes[MAX_EDGES_PER_NODE];
37         uint8_t next_percentage[MAX_EDGES_PER_NODE];
38 };
39
40 struct test_graph_perf {
41         uint16_t nb_nodes;
42         rte_graph_t graph_id;
43         struct test_node_data *node_data;
44 };
45
46 struct graph_lcore_data {
47         uint8_t done;
48         rte_graph_t graph_id;
49 };
50
51 static struct test_node_data *
52 graph_get_node_data(struct test_graph_perf *graph_data, rte_node_t id)
53 {
54         struct test_node_data *node_data = NULL;
55         int i;
56
57         for (i = 0; i < graph_data->nb_nodes; i++)
58                 if (graph_data->node_data[i].node_id == id) {
59                         node_data = &graph_data->node_data[i];
60                         break;
61                 }
62
63         return node_data;
64 }
65
66 static int
67 test_node_ctx_init(const struct rte_graph *graph, struct rte_node *node)
68 {
69         struct test_graph_perf *graph_data;
70         struct test_node_data *node_data;
71         const struct rte_memzone *mz;
72         rte_node_t nid = node->id;
73         rte_edge_t edge = 0;
74         int i;
75
76         RTE_SET_USED(graph);
77
78         mz = rte_memzone_lookup(TEST_GRAPH_PERF_MZ);
79         if (mz == NULL)
80                 return -ENOMEM;
81         graph_data = mz->addr;
82         node_data = graph_get_node_data(graph_data, nid);
83         node->ctx[0] = node->nb_edges;
84         for (i = 0; i < node->nb_edges && !node_data->is_sink; i++, edge++) {
85                 node->ctx[i + 1] = edge;
86                 node->ctx[i + 9] = node_data->next_percentage[i];
87         }
88
89         return 0;
90 }
91
92 /* Source node function */
93 static uint16_t
94 test_perf_node_worker_source(struct rte_graph *graph, struct rte_node *node,
95                              void **objs, uint16_t nb_objs)
96 {
97         uint16_t count;
98         int i;
99
100         RTE_SET_USED(objs);
101         RTE_SET_USED(nb_objs);
102
103         /* Create a proportional stream for every next */
104         for (i = 0; i < node->ctx[0]; i++) {
105                 count = (node->ctx[i + 9] * RTE_GRAPH_BURST_SIZE) / 100;
106                 rte_node_next_stream_get(graph, node, node->ctx[i + 1], count);
107                 rte_node_next_stream_put(graph, node, node->ctx[i + 1], count);
108         }
109
110         return RTE_GRAPH_BURST_SIZE;
111 }
112
113 static struct rte_node_register test_graph_perf_source = {
114         .name = TEST_GRAPH_SRC_NAME,
115         .process = test_perf_node_worker_source,
116         .flags = RTE_NODE_SOURCE_F,
117         .init = test_node_ctx_init,
118 };
119
120 RTE_NODE_REGISTER(test_graph_perf_source);
121
122 static uint16_t
123 test_perf_node_worker_source_burst_one(struct rte_graph *graph,
124                                        struct rte_node *node, void **objs,
125                                        uint16_t nb_objs)
126 {
127         uint16_t count;
128         int i;
129
130         RTE_SET_USED(objs);
131         RTE_SET_USED(nb_objs);
132
133         /* Create a proportional stream for every next */
134         for (i = 0; i < node->ctx[0]; i++) {
135                 count = (node->ctx[i + 9]) / 100;
136                 rte_node_next_stream_get(graph, node, node->ctx[i + 1], count);
137                 rte_node_next_stream_put(graph, node, node->ctx[i + 1], count);
138         }
139
140         return 1;
141 }
142
143 static struct rte_node_register test_graph_perf_source_burst_one = {
144         .name = TEST_GRAPH_SRC_BRST_ONE_NAME,
145         .process = test_perf_node_worker_source_burst_one,
146         .flags = RTE_NODE_SOURCE_F,
147         .init = test_node_ctx_init,
148 };
149
150 RTE_NODE_REGISTER(test_graph_perf_source_burst_one);
151
152 /* Worker node function */
153 static uint16_t
154 test_perf_node_worker(struct rte_graph *graph, struct rte_node *node,
155                       void **objs, uint16_t nb_objs)
156 {
157         uint16_t next = 0;
158         uint16_t enq = 0;
159         uint16_t count;
160         int i;
161
162         /* Move stream for single next node */
163         if (node->ctx[0] == 1) {
164                 rte_node_next_stream_move(graph, node, node->ctx[1]);
165                 return nb_objs;
166         }
167
168         /* Enqueue objects to next nodes proportionally */
169         for (i = 0; i < node->ctx[0]; i++) {
170                 next = node->ctx[i + 1];
171                 count = (node->ctx[i + 9] * nb_objs) / 100;
172                 enq += count;
173                 while (count) {
174                         switch (count & (4 - 1)) {
175                         case 0:
176                                 rte_node_enqueue_x4(graph, node, next, objs[0],
177                                                     objs[1], objs[2], objs[3]);
178                                 objs += 4;
179                                 count -= 4;
180                                 break;
181                         case 1:
182                                 rte_node_enqueue_x1(graph, node, next, objs[0]);
183                                 objs += 1;
184                                 count -= 1;
185                                 break;
186                         case 2:
187                                 rte_node_enqueue_x2(graph, node, next, objs[0],
188                                                     objs[1]);
189                                 objs += 2;
190                                 count -= 2;
191                                 break;
192                         case 3:
193                                 rte_node_enqueue_x2(graph, node, next, objs[0],
194                                                     objs[1]);
195                                 rte_node_enqueue_x1(graph, node, next, objs[0]);
196                                 objs += 3;
197                                 count -= 3;
198                                 break;
199                         }
200                 }
201         }
202
203         if (enq != nb_objs)
204                 rte_node_enqueue(graph, node, next, objs, nb_objs - enq);
205
206         return nb_objs;
207 }
208
209 static struct rte_node_register test_graph_perf_worker = {
210         .name = TEST_GRAPH_WRK_NAME,
211         .process = test_perf_node_worker,
212         .init = test_node_ctx_init,
213 };
214
215 RTE_NODE_REGISTER(test_graph_perf_worker);
216
217 /* Last node in graph a.k.a sink node */
218 static uint16_t
219 test_perf_node_sink(struct rte_graph *graph, struct rte_node *node, void **objs,
220                     uint16_t nb_objs)
221 {
222         RTE_SET_USED(graph);
223         RTE_SET_USED(node);
224         RTE_SET_USED(objs);
225         RTE_SET_USED(nb_objs);
226
227         return nb_objs;
228 }
229
230 static struct rte_node_register test_graph_perf_sink = {
231         .name = TEST_GRAPH_SNK_NAME,
232         .process = test_perf_node_sink,
233         .init = test_node_ctx_init,
234 };
235
236 RTE_NODE_REGISTER(test_graph_perf_sink);
237
238 static int
239 graph_perf_setup(void)
240 {
241         if (rte_lcore_count() < 2) {
242                 printf("Test requires at least 2 lcores\n");
243                 return TEST_SKIPPED;
244         }
245
246         return 0;
247 }
248
249 static void
250 graph_perf_teardown(void)
251 {
252 }
253
254 static inline rte_node_t
255 graph_node_get(const char *pname, char *nname)
256 {
257         rte_node_t pnode_id = rte_node_from_name(pname);
258         char lookup_name[RTE_NODE_NAMESIZE];
259         rte_node_t node_id;
260
261         snprintf(lookup_name, RTE_NODE_NAMESIZE, "%s-%s", pname, nname);
262         node_id = rte_node_from_name(lookup_name);
263
264         if (node_id != RTE_NODE_ID_INVALID) {
265                 if (rte_node_edge_count(node_id))
266                         rte_node_edge_shrink(node_id, 0);
267                 return node_id;
268         }
269
270         return rte_node_clone(pnode_id, nname);
271 }
272
273 static uint16_t
274 graph_node_count_edges(uint32_t stage, uint16_t node, uint16_t nodes_per_stage,
275                        uint8_t edge_map[][nodes_per_stage][nodes_per_stage],
276                        char *ename[], struct test_node_data *node_data,
277                        rte_node_t **node_map)
278 {
279         uint8_t total_percent = 0;
280         uint16_t edges = 0;
281         int i;
282
283         for (i = 0; i < nodes_per_stage && edges < MAX_EDGES_PER_NODE; i++) {
284                 if (edge_map[stage + 1][i][node]) {
285                         ename[edges] = malloc(sizeof(char) * RTE_NODE_NAMESIZE);
286                         snprintf(ename[edges], RTE_NODE_NAMESIZE, "%s",
287                                  rte_node_id_to_name(node_map[stage + 1][i]));
288                         node_data->next_nodes[edges] = node_map[stage + 1][i];
289                         node_data->next_percentage[edges] =
290                                 edge_map[stage + 1][i][node];
291                         edges++;
292                         total_percent += edge_map[stage + 1][i][node];
293                 }
294         }
295
296         if (edges >= MAX_EDGES_PER_NODE || (edges && total_percent != 100)) {
297                 for (i = 0; i < edges; i++)
298                         free(ename[i]);
299                 return RTE_EDGE_ID_INVALID;
300         }
301
302         return edges;
303 }
304
305 static int
306 graph_init(const char *gname, uint8_t nb_srcs, uint8_t nb_sinks,
307            uint32_t stages, uint16_t nodes_per_stage,
308            uint8_t src_map[][nodes_per_stage], uint8_t snk_map[][nb_sinks],
309            uint8_t edge_map[][nodes_per_stage][nodes_per_stage],
310            uint8_t burst_one)
311 {
312         struct test_graph_perf *graph_data;
313         char nname[RTE_NODE_NAMESIZE / 2];
314         struct test_node_data *node_data;
315         char *ename[nodes_per_stage];
316         struct rte_graph_param gconf;
317         const struct rte_memzone *mz;
318         uint8_t total_percent = 0;
319         rte_node_t *src_nodes;
320         rte_node_t *snk_nodes;
321         rte_node_t **node_map;
322         char **node_patterns;
323         rte_graph_t graph_id;
324         rte_edge_t edges;
325         rte_edge_t count;
326         uint32_t i, j, k;
327
328         mz = rte_memzone_reserve(TEST_GRAPH_PERF_MZ,
329                                  sizeof(struct test_graph_perf), 0, 0);
330         if (mz == NULL) {
331                 printf("Failed to allocate graph common memory\n");
332                 return -ENOMEM;
333         }
334
335         graph_data = mz->addr;
336         graph_data->nb_nodes = 0;
337         graph_data->node_data =
338                 malloc(sizeof(struct test_node_data) *
339                        (nb_srcs + nb_sinks + stages * nodes_per_stage));
340         if (graph_data->node_data == NULL) {
341                 printf("Failed to reserve memzone for graph data\n");
342                 goto memzone_free;
343         }
344
345         node_patterns = malloc(sizeof(char *) *
346                                (nb_srcs + nb_sinks + stages * nodes_per_stage));
347         if (node_patterns == NULL) {
348                 printf("Failed to reserve memory for node patterns\n");
349                 goto data_free;
350         }
351
352         src_nodes = malloc(sizeof(rte_node_t) * nb_srcs);
353         if (src_nodes == NULL) {
354                 printf("Failed to reserve memory for src nodes\n");
355                 goto pattern_free;
356         }
357
358         snk_nodes = malloc(sizeof(rte_node_t) * nb_sinks);
359         if (snk_nodes == NULL) {
360                 printf("Failed to reserve memory for snk nodes\n");
361                 goto src_free;
362         }
363
364         node_map = malloc(sizeof(rte_node_t *) * stages +
365                           sizeof(rte_node_t) * nodes_per_stage * stages);
366         if (node_map == NULL) {
367                 printf("Failed to reserve memory for node map\n");
368                 goto snk_free;
369         }
370
371         /* Setup the Graph */
372         for (i = 0; i < stages; i++) {
373                 node_map[i] =
374                         (rte_node_t *)(node_map + stages) + nodes_per_stage * i;
375                 for (j = 0; j < nodes_per_stage; j++) {
376                         total_percent = 0;
377                         for (k = 0; k < nodes_per_stage; k++)
378                                 total_percent += edge_map[i][j][k];
379                         if (!total_percent)
380                                 continue;
381                         node_patterns[graph_data->nb_nodes] =
382                                 malloc(RTE_NODE_NAMESIZE);
383                         if (node_patterns[graph_data->nb_nodes] == NULL) {
384                                 printf("Failed to create memory for pattern\n");
385                                 goto pattern_name_free;
386                         }
387
388                         /* Clone a worker node */
389                         snprintf(nname, sizeof(nname), "%d-%d", i, j);
390                         node_map[i][j] =
391                                 graph_node_get(TEST_GRAPH_WRK_NAME, nname);
392                         if (node_map[i][j] == RTE_NODE_ID_INVALID) {
393                                 printf("Failed to create node[%s]\n", nname);
394                                 graph_data->nb_nodes++;
395                                 goto pattern_name_free;
396                         }
397                         snprintf(node_patterns[graph_data->nb_nodes],
398                                  RTE_NODE_NAMESIZE, "%s",
399                                  rte_node_id_to_name(node_map[i][j]));
400                         node_data =
401                                 &graph_data->node_data[graph_data->nb_nodes];
402                         node_data->node_id = node_map[i][j];
403                         node_data->is_sink = false;
404                         graph_data->nb_nodes++;
405                 }
406         }
407
408         for (i = 0; i < stages - 1; i++) {
409                 for (j = 0; j < nodes_per_stage; j++) {
410                         /* Count edges i.e connections of worker node to next */
411                         node_data =
412                                 graph_get_node_data(graph_data, node_map[i][j]);
413                         edges = graph_node_count_edges(i, j, nodes_per_stage,
414                                                        edge_map, ename,
415                                                        node_data, node_map);
416                         if (edges == RTE_EDGE_ID_INVALID) {
417                                 printf("Invalid edge configuration\n");
418                                 goto pattern_name_free;
419                         }
420                         if (!edges)
421                                 continue;
422
423                         /* Connect a node in stage 'i' to nodes
424                          * in stage 'i + 1' with edges.
425                          */
426                         count = rte_node_edge_update(
427                                 node_map[i][j], 0,
428                                 (const char **)(uintptr_t)ename, edges);
429                         for (k = 0; k < edges; k++)
430                                 free(ename[k]);
431                         if (count != edges) {
432                                 printf("Couldn't add edges %d %d\n", edges,
433                                        count);
434                                 goto pattern_name_free;
435                         }
436                 }
437         }
438
439         /* Setup Source nodes */
440         for (i = 0; i < nb_srcs; i++) {
441                 edges = 0;
442                 total_percent = 0;
443                 node_patterns[graph_data->nb_nodes] = malloc(RTE_NODE_NAMESIZE);
444                 if (node_patterns[graph_data->nb_nodes] == NULL) {
445                         printf("Failed to create memory for pattern\n");
446                         goto pattern_name_free;
447                 }
448                 /* Clone a source node */
449                 snprintf(nname, sizeof(nname), "%d", i);
450                 src_nodes[i] =
451                         graph_node_get(burst_one ? TEST_GRAPH_SRC_BRST_ONE_NAME
452                                                  : TEST_GRAPH_SRC_NAME,
453                                        nname);
454                 if (src_nodes[i] == RTE_NODE_ID_INVALID) {
455                         printf("Failed to create node[%s]\n", nname);
456                         graph_data->nb_nodes++;
457                         goto pattern_name_free;
458                 }
459                 snprintf(node_patterns[graph_data->nb_nodes], RTE_NODE_NAMESIZE,
460                          "%s", rte_node_id_to_name(src_nodes[i]));
461                 node_data = &graph_data->node_data[graph_data->nb_nodes];
462                 node_data->node_id = src_nodes[i];
463                 node_data->is_sink = false;
464                 graph_data->nb_nodes++;
465
466                 /* Prepare next node list  to connect to */
467                 for (j = 0; j < nodes_per_stage; j++) {
468                         if (!src_map[i][j])
469                                 continue;
470                         ename[edges] = malloc(sizeof(char) * RTE_NODE_NAMESIZE);
471                         snprintf(ename[edges], RTE_NODE_NAMESIZE, "%s",
472                                  rte_node_id_to_name(node_map[0][j]));
473                         node_data->next_nodes[edges] = node_map[0][j];
474                         node_data->next_percentage[edges] = src_map[i][j];
475                         edges++;
476                         total_percent += src_map[i][j];
477                 }
478
479                 if (!edges)
480                         continue;
481                 if (edges >= MAX_EDGES_PER_NODE || total_percent != 100) {
482                         printf("Invalid edge configuration\n");
483                         for (j = 0; j < edges; j++)
484                                 free(ename[j]);
485                         goto pattern_name_free;
486                 }
487
488                 /* Connect to list of next nodes using edges */
489                 count = rte_node_edge_update(src_nodes[i], 0,
490                                              (const char **)(uintptr_t)ename,
491                                              edges);
492                 for (k = 0; k < edges; k++)
493                         free(ename[k]);
494                 if (count != edges) {
495                         printf("Couldn't add edges %d %d\n", edges, count);
496                         goto pattern_name_free;
497                 }
498         }
499
500         /* Setup Sink nodes */
501         for (i = 0; i < nb_sinks; i++) {
502                 node_patterns[graph_data->nb_nodes] = malloc(RTE_NODE_NAMESIZE);
503                 if (node_patterns[graph_data->nb_nodes] == NULL) {
504                         printf("Failed to create memory for pattern\n");
505                         goto pattern_name_free;
506                 }
507
508                 /* Clone a sink node */
509                 snprintf(nname, sizeof(nname), "%d", i);
510                 snk_nodes[i] = graph_node_get(TEST_GRAPH_SNK_NAME, nname);
511                 if (snk_nodes[i] == RTE_NODE_ID_INVALID) {
512                         printf("Failed to create node[%s]\n", nname);
513                         graph_data->nb_nodes++;
514                         goto pattern_name_free;
515                 }
516                 snprintf(node_patterns[graph_data->nb_nodes], RTE_NODE_NAMESIZE,
517                          "%s", rte_node_id_to_name(snk_nodes[i]));
518                 node_data = &graph_data->node_data[graph_data->nb_nodes];
519                 node_data->node_id = snk_nodes[i];
520                 node_data->is_sink = true;
521                 graph_data->nb_nodes++;
522         }
523
524         /* Connect last stage worker nodes to sink nodes */
525         for (i = 0; i < nodes_per_stage; i++) {
526                 edges = 0;
527                 total_percent = 0;
528                 node_data = graph_get_node_data(graph_data,
529                                                 node_map[stages - 1][i]);
530                 /* Prepare list of sink nodes to connect to */
531                 for (j = 0; j < nb_sinks; j++) {
532                         if (!snk_map[i][j])
533                                 continue;
534                         ename[edges] = malloc(sizeof(char) * RTE_NODE_NAMESIZE);
535                         snprintf(ename[edges], RTE_NODE_NAMESIZE, "%s",
536                                  rte_node_id_to_name(snk_nodes[j]));
537                         node_data->next_nodes[edges] = snk_nodes[j];
538                         node_data->next_percentage[edges] = snk_map[i][j];
539                         edges++;
540                         total_percent += snk_map[i][j];
541                 }
542                 if (!edges)
543                         continue;
544                 if (edges >= MAX_EDGES_PER_NODE || total_percent != 100) {
545                         printf("Invalid edge configuration\n");
546                         for (j = 0; j < edges; j++)
547                                 free(ename[i]);
548                         goto pattern_name_free;
549                 }
550
551                 /* Connect a worker node to a list of sink nodes */
552                 count = rte_node_edge_update(node_map[stages - 1][i], 0,
553                                              (const char **)(uintptr_t)ename,
554                                              edges);
555                 for (k = 0; k < edges; k++)
556                         free(ename[k]);
557                 if (count != edges) {
558                         printf("Couldn't add edges %d %d\n", edges, count);
559                         goto pattern_name_free;
560                 }
561         }
562
563         /* Create a Graph */
564         gconf.socket_id = SOCKET_ID_ANY;
565         gconf.nb_node_patterns = graph_data->nb_nodes;
566         gconf.node_patterns = (const char **)(uintptr_t)node_patterns;
567
568         graph_id = rte_graph_create(gname, &gconf);
569         if (graph_id == RTE_GRAPH_ID_INVALID) {
570                 printf("Graph creation failed with error = %d\n", rte_errno);
571                 goto pattern_name_free;
572         }
573         graph_data->graph_id = graph_id;
574
575         free(node_map);
576         for (i = 0; i < graph_data->nb_nodes; i++)
577                 free(node_patterns[i]);
578         free(snk_nodes);
579         free(src_nodes);
580         free(node_patterns);
581         return 0;
582
583 pattern_name_free:
584         free(node_map);
585         for (i = 0; i < graph_data->nb_nodes; i++)
586                 free(node_patterns[i]);
587 snk_free:
588         free(snk_nodes);
589 src_free:
590         free(src_nodes);
591 pattern_free:
592         free(node_patterns);
593 data_free:
594         free(graph_data->node_data);
595 memzone_free:
596         rte_memzone_free(mz);
597         return -ENOMEM;
598 }
599
600 /* Worker thread function */
601 static int
602 _graph_perf_wrapper(void *args)
603 {
604         struct graph_lcore_data *data = args;
605         struct rte_graph *graph;
606
607         /* Lookup graph */
608         graph = rte_graph_lookup(rte_graph_id_to_name(data->graph_id));
609
610         /* Graph walk until done */
611         while (!data->done)
612                 rte_graph_walk(graph);
613
614         return 0;
615 }
616
617 static int
618 measure_perf_get(rte_graph_t graph_id)
619 {
620         const char *pattern = rte_graph_id_to_name(graph_id);
621         uint32_t lcore_id = rte_get_next_lcore(-1, 1, 0);
622         struct rte_graph_cluster_stats_param param;
623         struct rte_graph_cluster_stats *stats;
624         struct graph_lcore_data *data;
625
626         data = rte_zmalloc("Graph_perf", sizeof(struct graph_lcore_data),
627                            RTE_CACHE_LINE_SIZE);
628         data->graph_id = graph_id;
629         data->done = 0;
630
631         /* Run graph worker thread function */
632         rte_eal_remote_launch(_graph_perf_wrapper, data, lcore_id);
633
634         /* Collect stats for few msecs */
635         if (rte_graph_has_stats_feature()) {
636                 memset(&param, 0, sizeof(param));
637                 param.f = stdout;
638                 param.socket_id = SOCKET_ID_ANY;
639                 param.graph_patterns = &pattern;
640                 param.nb_graph_patterns = 1;
641
642                 stats = rte_graph_cluster_stats_create(&param);
643                 if (stats == NULL) {
644                         printf("Failed to create stats\n");
645                         return -ENOMEM;
646                 }
647
648                 rte_delay_ms(3E2);
649                 rte_graph_cluster_stats_get(stats, true);
650                 rte_delay_ms(1E3);
651                 rte_graph_cluster_stats_get(stats, false);
652                 rte_graph_cluster_stats_destroy(stats);
653         } else
654                 rte_delay_ms(1E3);
655
656         data->done = 1;
657         rte_eal_wait_lcore(lcore_id);
658
659         return 0;
660 }
661
662 static inline void
663 graph_fini(void)
664 {
665         const struct rte_memzone *mz = rte_memzone_lookup(TEST_GRAPH_PERF_MZ);
666         struct test_graph_perf *graph_data;
667
668         if (mz == NULL)
669                 return;
670         graph_data = mz->addr;
671
672         rte_graph_destroy(graph_data->graph_id);
673         free(graph_data->node_data);
674         rte_memzone_free(rte_memzone_lookup(TEST_GRAPH_PERF_MZ));
675 }
676
677 static int
678 measure_perf(void)
679 {
680         const struct rte_memzone *mz;
681         struct test_graph_perf *graph_data;
682
683         mz = rte_memzone_lookup(TEST_GRAPH_PERF_MZ);
684         if (mz == NULL)
685                 return -ENOMEM;
686         graph_data = mz->addr;
687
688         return measure_perf_get(graph_data->graph_id);
689 }
690
691 static inline int
692 graph_hr_4s_1n_1src_1snk(void)
693 {
694         return measure_perf();
695 }
696
697 static inline int
698 graph_hr_4s_1n_1src_1snk_brst_one(void)
699 {
700         return measure_perf();
701 }
702
703 static inline int
704 graph_hr_4s_1n_2src_1snk(void)
705 {
706         return measure_perf();
707 }
708
709 static inline int
710 graph_hr_4s_1n_1src_2snk(void)
711 {
712         return measure_perf();
713 }
714
715 static inline int
716 graph_tree_4s_4n_1src_4snk(void)
717 {
718         return measure_perf();
719 }
720
721 static inline int
722 graph_reverse_tree_3s_4n_1src_1snk(void)
723 {
724         return measure_perf();
725 }
726
727 static inline int
728 graph_parallel_tree_5s_4n_4src_4snk(void)
729 {
730         return measure_perf();
731 }
732
733 /* Graph Topology
734  * nodes per stage:     1
735  * stages:              4
736  * src:                 1
737  * sink:                1
738  */
739 static inline int
740 graph_init_hr(void)
741 {
742         uint8_t edge_map[][1][1] = {
743                 { {100} },
744                 { {100} },
745                 { {100} },
746                 { {100} },
747         };
748         uint8_t src_map[][1] = { {100} };
749         uint8_t snk_map[][1] = { {100} };
750
751         return graph_init("graph_hr", SOURCES(src_map), SINKS(snk_map),
752                           STAGES(edge_map), NODES_PER_STAGE(edge_map), src_map,
753                           snk_map, edge_map, 0);
754 }
755
756 /* Graph Topology
757  * nodes per stage:     1
758  * stages:              4
759  * src:                 1
760  * sink:                1
761  */
762 static inline int
763 graph_init_hr_brst_one(void)
764 {
765         uint8_t edge_map[][1][1] = {
766                 { {100} },
767                 { {100} },
768                 { {100} },
769                 { {100} },
770         };
771         uint8_t src_map[][1] = { {100} };
772         uint8_t snk_map[][1] = { {100} };
773
774         return graph_init("graph_hr", SOURCES(src_map), SINKS(snk_map),
775                           STAGES(edge_map), NODES_PER_STAGE(edge_map), src_map,
776                           snk_map, edge_map, 1);
777 }
778
779 /* Graph Topology
780  * nodes per stage:     1
781  * stages:              4
782  * src:                 2
783  * sink:                1
784  */
785 static inline int
786 graph_init_hr_multi_src(void)
787 {
788         uint8_t edge_map[][1][1] = {
789                 { {100} },
790                 { {100} },
791                 { {100} },
792                 { {100} },
793         };
794         uint8_t src_map[][1] = {
795                 {100}, {100}
796         };
797         uint8_t snk_map[][1] = { {100} };
798
799         return graph_init("graph_hr", SOURCES(src_map), SINKS(snk_map),
800                           STAGES(edge_map), NODES_PER_STAGE(edge_map), src_map,
801                           snk_map, edge_map, 0);
802 }
803
804 /* Graph Topology
805  * nodes per stage:     1
806  * stages:              4
807  * src:                 1
808  * sink:                2
809  */
810 static inline int
811 graph_init_hr_multi_snk(void)
812 {
813         uint8_t edge_map[][1][1] = {
814                 { {100} },
815                 { {100} },
816                 { {100} },
817                 { {100} },
818         };
819         uint8_t src_map[][1] = { {100} };
820         uint8_t snk_map[][2] = { {50, 50} };
821
822         return graph_init("graph_hr", SOURCES(src_map), SINKS(snk_map),
823                           STAGES(edge_map), NODES_PER_STAGE(edge_map), src_map,
824                           snk_map, edge_map, 0);
825 }
826
827 /* Graph Topology
828  * nodes per stage:     4
829  * stages:              4
830  * src:                 1
831  * sink:                4
832  */
833 static inline int
834 graph_init_tree(void)
835 {
836         uint8_t edge_map[][4][4] = {
837                 {
838                         {100, 0, 0, 0},
839                         {0, 0, 0, 0},
840                         {0, 0, 0, 0},
841                         {0, 0, 0, 0}
842                 },
843                 {
844                         {50, 0, 0, 0},
845                         {50, 0, 0, 0},
846                         {0, 0, 0, 0},
847                         {0, 0, 0, 0}
848                 },
849                 {
850                         {33, 33, 0, 0},
851                         {34, 34, 0, 0},
852                         {33, 33, 0, 0},
853                         {0, 0, 0, 0}
854                 },
855                 {
856                         {25, 25, 25, 0},
857                         {25, 25, 25, 0},
858                         {25, 25, 25, 0},
859                         {25, 25, 25, 0}
860                 }
861         };
862         uint8_t src_map[][4] = { {100, 0, 0, 0} };
863         uint8_t snk_map[][4] = {
864                 {100, 0, 0, 0},
865                 {0, 100, 0, 0},
866                 {0, 0, 100, 0},
867                 {0, 0, 0, 100}
868         };
869
870         return graph_init("graph_full_split", SOURCES(src_map), SINKS(snk_map),
871                           STAGES(edge_map), NODES_PER_STAGE(edge_map), src_map,
872                           snk_map, edge_map, 0);
873 }
874
875 /* Graph Topology
876  * nodes per stage:     4
877  * stages:              3
878  * src:                 1
879  * sink:                1
880  */
881 static inline int
882 graph_init_reverse_tree(void)
883 {
884         uint8_t edge_map[][4][4] = {
885                 {
886                         {25, 25, 25, 25},
887                         {25, 25, 25, 25},
888                         {25, 25, 25, 25},
889                         {25, 25, 25, 25}
890                 },
891                 {
892                         {33, 33, 33, 33},
893                         {33, 33, 33, 33},
894                         {34, 34, 34, 34},
895                         {0, 0, 0, 0}
896                 },
897                 {
898                         {50, 50, 50, 0},
899                         {50, 50, 50, 0},
900                         {0, 0, 0, 0},
901                         {0, 0, 0, 0}
902                 },
903         };
904         uint8_t src_map[][4] = { {25, 25, 25, 25} };
905         uint8_t snk_map[][1] = { {100}, {100}, {0}, {0} };
906
907         return graph_init("graph_full_split", SOURCES(src_map), SINKS(snk_map),
908                           STAGES(edge_map), NODES_PER_STAGE(edge_map), src_map,
909                           snk_map, edge_map, 0);
910 }
911
912 /* Graph Topology
913  * nodes per stage:     4
914  * stages:              5
915  * src:                 4
916  * sink:                4
917  */
918 static inline int
919 graph_init_parallel_tree(void)
920 {
921         uint8_t edge_map[][4][4] = {
922                 {
923                         {100, 0, 0, 0},
924                         {0, 100, 0, 0},
925                         {0, 0, 100, 0},
926                         {0, 0, 0, 100}
927                 },
928                 {
929                         {100, 0, 0, 0},
930                         {0, 100, 0, 0},
931                         {0, 0, 100, 0},
932                         {0, 0, 0, 100}
933                 },
934                 {
935                         {100, 0, 0, 0},
936                         {0, 100, 0, 0},
937                         {0, 0, 100, 0},
938                         {0, 0, 0, 100}
939                 },
940                 {
941                         {100, 0, 0, 0},
942                         {0, 100, 0, 0},
943                         {0, 0, 100, 0},
944                         {0, 0, 0, 100}
945                 },
946                 {
947                         {100, 0, 0, 0},
948                         {0, 100, 0, 0},
949                         {0, 0, 100, 0},
950                         {0, 0, 0, 100}
951                 },
952         };
953         uint8_t src_map[][4] = {
954                 {100, 0, 0, 0},
955                 {0, 100, 0, 0},
956                 {0, 0, 100, 0},
957                 {0, 0, 0, 100}
958         };
959         uint8_t snk_map[][4] = {
960                 {100, 0, 0, 0},
961                 {0, 100, 0, 0},
962                 {0, 0, 100, 0},
963                 {0, 0, 0, 100}
964         };
965
966         return graph_init("graph_parallel", SOURCES(src_map), SINKS(snk_map),
967                           STAGES(edge_map), NODES_PER_STAGE(edge_map), src_map,
968                           snk_map, edge_map, 0);
969 }
970
971 /** Graph Creation cheat sheet
972  *  edge_map -> dictates graph flow from worker stage 0 to worker stage n-1.
973  *  src_map  -> dictates source nodes enqueue percentage to worker stage 0.
974  *  snk_map  -> dictates stage n-1 enqueue percentage to sink.
975  *
976  *  Layout:
977  *  edge_map[<nb_stages>][<nodes_per_stg>][<nodes_in_nxt_stg = nodes_per_stg>]
978  *  src_map[<nb_sources>][<nodes_in_stage0 = nodes_per_stage>]
979  *  snk_map[<nodes_in_stage(n-1) = nodes_per_stage>][<nb_sinks>]
980  *
981  *  The last array dictates the percentage of received objs to enqueue to next
982  *  stage.
983  *
984  *  Note: edge_map[][0][] will always be unused as it will receive from source
985  *
986  *  Example:
987  *      Graph:
988  *      http://bit.ly/2PqbqOy
989  *      Each stage(n) connects to all nodes in the next stage in decreasing
990  *      order.
991  *      Since we can't resize the edge_map dynamically we get away by creating
992  *      dummy nodes and assigning 0 percentages.
993  *      Max nodes across all stages = 4
994  *      stages = 3
995  *      nb_src = 1
996  *      nb_snk = 1
997  *                         // Stages
998  *      edge_map[][4][4] = {
999  *              // Nodes per stage
1000  *              {
1001  *                  {25, 25, 25, 25},
1002  *                  {25, 25, 25, 25},
1003  *                  {25, 25, 25, 25},
1004  *                  {25, 25, 25, 25}
1005  *              },      // This will be unused.
1006  *              {
1007  *                  // Nodes enabled in current stage + prev stage enq %
1008  *                  {33, 33, 33, 33},
1009  *                  {33, 33, 33, 33},
1010  *                  {34, 34, 34, 34},
1011  *                  {0, 0, 0, 0}
1012  *              },
1013  *              {
1014  *                  {50, 50, 50, 0},
1015  *                  {50, 50, 50, 0},
1016  *                  {0, 0, 0, 0},
1017  *                  {0, 0, 0, 0}
1018  *              },
1019  *      };
1020  *      Above, each stage tells how much it should receive from previous except
1021  *      from stage_0.
1022  *
1023  *      src_map[][4] = { {25, 25, 25, 25} };
1024  *      Here, we tell each source the % it has to send to stage_0 nodes. In
1025  *      case we want 2 source node we can declare as
1026  *      src_map[][4] = { {25, 25, 25, 25}, {25, 25, 25, 25} };
1027  *
1028  *      snk_map[][1] = { {100}, {100}, {0}, {0} }
1029  *      Here, we tell stage - 1 nodes how much to enqueue to sink_0.
1030  *      If we have 2 sinks we can do as follows
1031  *      snk_map[][2] = { {50, 50}, {50, 50}, {0, 0}, {0, 0} }
1032  */
1033
1034 static struct unit_test_suite graph_perf_testsuite = {
1035         .suite_name = "Graph library performance test suite",
1036         .setup = graph_perf_setup,
1037         .teardown = graph_perf_teardown,
1038         .unit_test_cases = {
1039                 TEST_CASE_ST(graph_init_hr, graph_fini,
1040                              graph_hr_4s_1n_1src_1snk),
1041                 TEST_CASE_ST(graph_init_hr_brst_one, graph_fini,
1042                              graph_hr_4s_1n_1src_1snk_brst_one),
1043                 TEST_CASE_ST(graph_init_hr_multi_src, graph_fini,
1044                              graph_hr_4s_1n_2src_1snk),
1045                 TEST_CASE_ST(graph_init_hr_multi_snk, graph_fini,
1046                              graph_hr_4s_1n_1src_2snk),
1047                 TEST_CASE_ST(graph_init_tree, graph_fini,
1048                              graph_tree_4s_4n_1src_4snk),
1049                 TEST_CASE_ST(graph_init_reverse_tree, graph_fini,
1050                              graph_reverse_tree_3s_4n_1src_1snk),
1051                 TEST_CASE_ST(graph_init_parallel_tree, graph_fini,
1052                              graph_parallel_tree_5s_4n_4src_4snk),
1053                 TEST_CASES_END(), /**< NULL terminate unit test array */
1054         },
1055 };
1056
1057 static int
1058 test_graph_perf_func(void)
1059 {
1060         return unit_test_suite_runner(&graph_perf_testsuite);
1061 }
1062
1063 REGISTER_TEST_COMMAND(graph_perf_autotest, test_graph_perf_func);