/
phprus
/
github_dpdk
Обзор
Документация
Войти
/
phprus
/
github_dpdk
Код
Задачи
Вики
Пакеты
0
Релизы
0
Аналитика
Безопасность
main
app/test/test_graph_perf.c
1 076 строк
25 KB
David Marchand
test: fix fast, perf and driver testsuites
15 сен 2023, 15:44
15 сен 2023, 15:44
d83fb96
Код
Авторство
О чём код?
/* SPDX-License-Identifier: BSD-3-Clause * Copyright(C) 2020 Marvell International Ltd. */ #include "test.h" #include <inttypes.h> #include <signal.h> #include <stdio.h> #include <unistd.h> #include <rte_common.h> #include <rte_cycles.h> #include <rte_errno.h> #ifdef RTE_EXEC_ENV_WINDOWS static int test_graph_perf_func(void) { printf("graph_perf not supported on Windows, skipping test\n"); return TEST_SKIPPED; } #else #include <rte_graph.h> #include <rte_graph_worker.h> #include <rte_lcore.h> #include <rte_malloc.h> #include <rte_mbuf.h> #define TEST_GRAPH_PERF_MZ "graph_perf_data" #define TEST_GRAPH_SRC_NAME "test_graph_perf_source" #define TEST_GRAPH_SRC_BRST_ONE_NAME "test_graph_perf_source_one" #define TEST_GRAPH_WRK_NAME "test_graph_perf_worker" #define TEST_GRAPH_SNK_NAME "test_graph_perf_sink" #define SOURCES(map) RTE_DIM(map) #define STAGES(map) RTE_DIM(map) #define NODES_PER_STAGE(map) RTE_DIM(map[0]) #define SINKS(map) RTE_DIM(map[0]) #define MAX_EDGES_PER_NODE 7 struct test_node_data { uint8_t node_id; uint8_t is_sink; uint8_t next_nodes[MAX_EDGES_PER_NODE]; uint8_t next_percentage[MAX_EDGES_PER_NODE]; }; struct test_graph_perf { uint16_t nb_nodes; rte_graph_t graph_id; struct test_node_data *node_data; }; struct graph_lcore_data { uint8_t done; rte_graph_t graph_id; }; static struct test_node_data * graph_get_node_data(struct test_graph_perf *graph_data, rte_node_t id) { struct test_node_data *node_data = NULL; int i; for (i = 0; i < graph_data->nb_nodes; i++) if (graph_data->node_data[i].node_id == id) { node_data = &graph_data->node_data[i]; break; } return node_data; } static int test_node_ctx_init(const struct rte_graph *graph, struct rte_node *node) { struct test_graph_perf *graph_data; struct test_node_data *node_data; const struct rte_memzone *mz; rte_node_t nid = node->id; rte_edge_t edge = 0; int i; RTE_SET_USED(graph); mz = rte_memzone_lookup(TEST_GRAPH_PERF_MZ); if (mz == NULL) return -ENOMEM; graph_data = mz->addr; node_data = graph_get_node_data(graph_data, nid); node->ctx[0] = node->nb_edges; for (i = 0; i < node->nb_edges && !node_data->is_sink; i++, edge++) { node->ctx[i + 1] = edge; node->ctx[i + 9] = node_data->next_percentage[i]; } return 0; } /* Source node function */ static uint16_t test_perf_node_worker_source(struct rte_graph *graph, struct rte_node *node, void **objs, uint16_t nb_objs) { uint16_t count; int i; RTE_SET_USED(objs); RTE_SET_USED(nb_objs); /* Create a proportional stream for every next */ for (i = 0; i < node->ctx[0]; i++) { count = (node->ctx[i + 9] * RTE_GRAPH_BURST_SIZE) / 100; rte_node_next_stream_get(graph, node, node->ctx[i + 1], count); rte_node_next_stream_put(graph, node, node->ctx[i + 1], count); } return RTE_GRAPH_BURST_SIZE; } static struct rte_node_register test_graph_perf_source = { .name = TEST_GRAPH_SRC_NAME, .process = test_perf_node_worker_source, .flags = RTE_NODE_SOURCE_F, .init = test_node_ctx_init, }; RTE_NODE_REGISTER(test_graph_perf_source); static uint16_t test_perf_node_worker_source_burst_one(struct rte_graph *graph, struct rte_node *node, void **objs, uint16_t nb_objs) { uint16_t count; int i; RTE_SET_USED(objs); RTE_SET_USED(nb_objs); /* Create a proportional stream for every next */ for (i = 0; i < node->ctx[0]; i++) { count = (node->ctx[i + 9]) / 100; rte_node_next_stream_get(graph, node, node->ctx[i + 1], count); rte_node_next_stream_put(graph, node, node->ctx[i + 1], count); } return 1; } static struct rte_node_register test_graph_perf_source_burst_one = { .name = TEST_GRAPH_SRC_BRST_ONE_NAME, .process = test_perf_node_worker_source_burst_one, .flags = RTE_NODE_SOURCE_F, .init = test_node_ctx_init, }; RTE_NODE_REGISTER(test_graph_perf_source_burst_one); /* Worker node function */ static uint16_t test_perf_node_worker(struct rte_graph *graph, struct rte_node *node, void **objs, uint16_t nb_objs) { uint16_t next = 0; uint16_t enq = 0; uint16_t count; int i; /* Move stream for single next node */ if (node->ctx[0] == 1) { rte_node_next_stream_move(graph, node, node->ctx[1]); return nb_objs; } /* Enqueue objects to next nodes proportionally */ for (i = 0; i < node->ctx[0]; i++) { next = node->ctx[i + 1]; count = (node->ctx[i + 9] * nb_objs) / 100; enq += count; while (count) { switch (count & (4 - 1)) { case 0: rte_node_enqueue_x4(graph, node, next, objs[0], objs[1], objs[2], objs[3]); objs += 4; count -= 4; break; case 1: rte_node_enqueue_x1(graph, node, next, objs[0]); objs += 1; count -= 1; break; case 2: rte_node_enqueue_x2(graph, node, next, objs[0], objs[1]); objs += 2; count -= 2; break; case 3: rte_node_enqueue_x2(graph, node, next, objs[0], objs[1]); rte_node_enqueue_x1(graph, node, next, objs[0]); objs += 3; count -= 3; break; } } } if (enq != nb_objs) rte_node_enqueue(graph, node, next, objs, nb_objs - enq); return nb_objs; } static struct rte_node_register test_graph_perf_worker = { .name = TEST_GRAPH_WRK_NAME, .process = test_perf_node_worker, .init = test_node_ctx_init, }; RTE_NODE_REGISTER(test_graph_perf_worker); /* Last node in graph a.k.a sink node */ static uint16_t test_perf_node_sink(struct rte_graph *graph, struct rte_node *node, void **objs, uint16_t nb_objs) { RTE_SET_USED(graph); RTE_SET_USED(node); RTE_SET_USED(objs); RTE_SET_USED(nb_objs); return nb_objs; } static struct rte_node_register test_graph_perf_sink = { .name = TEST_GRAPH_SNK_NAME, .process = test_perf_node_sink, .init = test_node_ctx_init, }; RTE_NODE_REGISTER(test_graph_perf_sink); static int graph_perf_setup(void) { if (rte_lcore_count() < 2) { printf("Test requires at least 2 lcores\n"); return TEST_SKIPPED; } return 0; } static void graph_perf_teardown(void) { } static inline rte_node_t graph_node_get(const char *pname, char *nname) { rte_node_t pnode_id = rte_node_from_name(pname); char lookup_name[RTE_NODE_NAMESIZE]; rte_node_t node_id; snprintf(lookup_name, RTE_NODE_NAMESIZE, "%s-%s", pname, nname); node_id = rte_node_from_name(lookup_name); if (node_id != RTE_NODE_ID_INVALID) { if (rte_node_edge_count(node_id)) rte_node_edge_shrink(node_id, 0); return node_id; } return rte_node_clone(pnode_id, nname); } static uint16_t graph_node_count_edges(uint32_t stage, uint16_t node, uint16_t nodes_per_stage, uint8_t edge_map[][nodes_per_stage][nodes_per_stage], char *ename[], struct test_node_data *node_data, rte_node_t **node_map) { uint8_t total_percent = 0; uint16_t edges = 0; int i; for (i = 0; i < nodes_per_stage && edges < MAX_EDGES_PER_NODE; i++) { if (edge_map[stage + 1][i][node]) { ename[edges] = malloc(sizeof(char) * RTE_NODE_NAMESIZE); snprintf(ename[edges], RTE_NODE_NAMESIZE, "%s", rte_node_id_to_name(node_map[stage + 1][i])); node_data->next_nodes[edges] = node_map[stage + 1][i]; node_data->next_percentage[edges] = edge_map[stage + 1][i][node]; edges++; total_percent += edge_map[stage + 1][i][node]; } } if (edges >= MAX_EDGES_PER_NODE || (edges && total_percent != 100)) { for (i = 0; i < edges; i++) free(ename[i]); return RTE_EDGE_ID_INVALID; } return edges; } static int graph_init(const char *gname, uint8_t nb_srcs, uint8_t nb_sinks, uint32_t stages, uint16_t nodes_per_stage, uint8_t src_map[][nodes_per_stage], uint8_t snk_map[][nb_sinks], uint8_t edge_map[][nodes_per_stage][nodes_per_stage], uint8_t burst_one) { struct test_graph_perf *graph_data; char nname[RTE_NODE_NAMESIZE / 2]; struct test_node_data *node_data; char *ename[nodes_per_stage]; struct rte_graph_param gconf = {0}; const struct rte_memzone *mz; uint8_t total_percent = 0; rte_node_t *src_nodes; rte_node_t *snk_nodes; rte_node_t **node_map; char **node_patterns; rte_graph_t graph_id; rte_edge_t edges; rte_edge_t count; uint32_t i, j, k; mz = rte_memzone_reserve(TEST_GRAPH_PERF_MZ, sizeof(struct test_graph_perf), 0, 0); if (mz == NULL) { printf("Failed to allocate graph common memory\n"); return -ENOMEM; } graph_data = mz->addr; graph_data->nb_nodes = 0; graph_data->node_data = malloc(sizeof(struct test_node_data) * (nb_srcs + nb_sinks + stages * nodes_per_stage)); if (graph_data->node_data == NULL) { printf("Failed to reserve memzone for graph data\n"); goto memzone_free; } node_patterns = malloc(sizeof(char *) * (nb_srcs + nb_sinks + stages * nodes_per_stage)); if (node_patterns == NULL) { printf("Failed to reserve memory for node patterns\n"); goto data_free; } src_nodes = malloc(sizeof(rte_node_t) * nb_srcs); if (src_nodes == NULL) { printf("Failed to reserve memory for src nodes\n"); goto pattern_free; } snk_nodes = malloc(sizeof(rte_node_t) * nb_sinks); if (snk_nodes == NULL) { printf("Failed to reserve memory for snk nodes\n"); goto src_free; } node_map = malloc(sizeof(rte_node_t *) * stages + sizeof(rte_node_t) * nodes_per_stage * stages); if (node_map == NULL) { printf("Failed to reserve memory for node map\n"); goto snk_free; } /* Setup the Graph */ for (i = 0; i < stages; i++) { node_map[i] = (rte_node_t *)(node_map + stages) + nodes_per_stage * i; for (j = 0; j < nodes_per_stage; j++) { total_percent = 0; for (k = 0; k < nodes_per_stage; k++) total_percent += edge_map[i][j][k]; if (!total_percent) continue; node_patterns[graph_data->nb_nodes] = malloc(RTE_NODE_NAMESIZE); if (node_patterns[graph_data->nb_nodes] == NULL) { printf("Failed to create memory for pattern\n"); goto pattern_name_free; } /* Clone a worker node */ snprintf(nname, sizeof(nname), "%d-%d", i, j); node_map[i][j] = graph_node_get(TEST_GRAPH_WRK_NAME, nname); if (node_map[i][j] == RTE_NODE_ID_INVALID) { printf("Failed to create node[%s]\n", nname); graph_data->nb_nodes++; goto pattern_name_free; } snprintf(node_patterns[graph_data->nb_nodes], RTE_NODE_NAMESIZE, "%s", rte_node_id_to_name(node_map[i][j])); node_data = &graph_data->node_data[graph_data->nb_nodes]; node_data->node_id = node_map[i][j]; node_data->is_sink = false; graph_data->nb_nodes++; } } for (i = 0; i < stages - 1; i++) { for (j = 0; j < nodes_per_stage; j++) { /* Count edges i.e connections of worker node to next */ node_data = graph_get_node_data(graph_data, node_map[i][j]); edges = graph_node_count_edges(i, j, nodes_per_stage, edge_map, ename, node_data, node_map); if (edges == RTE_EDGE_ID_INVALID) { printf("Invalid edge configuration\n"); goto pattern_name_free; } if (!edges) continue; /* Connect a node in stage 'i' to nodes * in stage 'i + 1' with edges. */ count = rte_node_edge_update( node_map[i][j], 0, (const char **)(uintptr_t)ename, edges); for (k = 0; k < edges; k++) free(ename[k]); if (count != edges) { printf("Couldn't add edges %d %d\n", edges, count); goto pattern_name_free; } } } /* Setup Source nodes */ for (i = 0; i < nb_srcs; i++) { edges = 0; total_percent = 0; node_patterns[graph_data->nb_nodes] = malloc(RTE_NODE_NAMESIZE); if (node_patterns[graph_data->nb_nodes] == NULL) { printf("Failed to create memory for pattern\n"); goto pattern_name_free; } /* Clone a source node */ snprintf(nname, sizeof(nname), "%d", i); src_nodes[i] = graph_node_get(burst_one ? TEST_GRAPH_SRC_BRST_ONE_NAME : TEST_GRAPH_SRC_NAME, nname); if (src_nodes[i] == RTE_NODE_ID_INVALID) { printf("Failed to create node[%s]\n", nname); graph_data->nb_nodes++; goto pattern_name_free; } snprintf(node_patterns[graph_data->nb_nodes], RTE_NODE_NAMESIZE, "%s", rte_node_id_to_name(src_nodes[i])); node_data = &graph_data->node_data[graph_data->nb_nodes]; node_data->node_id = src_nodes[i]; node_data->is_sink = false; graph_data->nb_nodes++; /* Prepare next node list to connect to */ for (j = 0; j < nodes_per_stage; j++) { if (!src_map[i][j]) continue; ename[edges] = malloc(sizeof(char) * RTE_NODE_NAMESIZE); snprintf(ename[edges], RTE_NODE_NAMESIZE, "%s", rte_node_id_to_name(node_map[0][j])); node_data->next_nodes[edges] = node_map[0][j]; node_data->next_percentage[edges] = src_map[i][j]; edges++; total_percent += src_map[i][j]; } if (!edges) continue; if (edges >= MAX_EDGES_PER_NODE || total_percent != 100) { printf("Invalid edge configuration\n"); for (j = 0; j < edges; j++) free(ename[j]); goto pattern_name_free; } /* Connect to list of next nodes using edges */ count = rte_node_edge_update(src_nodes[i], 0, (const char **)(uintptr_t)ename, edges); for (k = 0; k < edges; k++) free(ename[k]); if (count != edges) { printf("Couldn't add edges %d %d\n", edges, count); goto pattern_name_free; } } /* Setup Sink nodes */ for (i = 0; i < nb_sinks; i++) { node_patterns[graph_data->nb_nodes] = malloc(RTE_NODE_NAMESIZE); if (node_patterns[graph_data->nb_nodes] == NULL) { printf("Failed to create memory for pattern\n"); goto pattern_name_free; } /* Clone a sink node */ snprintf(nname, sizeof(nname), "%d", i); snk_nodes[i] = graph_node_get(TEST_GRAPH_SNK_NAME, nname); if (snk_nodes[i] == RTE_NODE_ID_INVALID) { printf("Failed to create node[%s]\n", nname); graph_data->nb_nodes++; goto pattern_name_free; } snprintf(node_patterns[graph_data->nb_nodes], RTE_NODE_NAMESIZE, "%s", rte_node_id_to_name(snk_nodes[i])); node_data = &graph_data->node_data[graph_data->nb_nodes]; node_data->node_id = snk_nodes[i]; node_data->is_sink = true; graph_data->nb_nodes++; } /* Connect last stage worker nodes to sink nodes */ for (i = 0; i < nodes_per_stage; i++) { edges = 0; total_percent = 0; node_data = graph_get_node_data(graph_data, node_map[stages - 1][i]); /* Prepare list of sink nodes to connect to */ for (j = 0; j < nb_sinks; j++) { if (!snk_map[i][j]) continue; ename[edges] = malloc(sizeof(char) * RTE_NODE_NAMESIZE); snprintf(ename[edges], RTE_NODE_NAMESIZE, "%s", rte_node_id_to_name(snk_nodes[j])); node_data->next_nodes[edges] = snk_nodes[j]; node_data->next_percentage[edges] = snk_map[i][j]; edges++; total_percent += snk_map[i][j]; } if (!edges) continue; if (edges >= MAX_EDGES_PER_NODE || total_percent != 100) { printf("Invalid edge configuration\n"); for (j = 0; j < edges; j++) free(ename[i]); goto pattern_name_free; } /* Connect a worker node to a list of sink nodes */ count = rte_node_edge_update(node_map[stages - 1][i], 0, (const char **)(uintptr_t)ename, edges); for (k = 0; k < edges; k++) free(ename[k]); if (count != edges) { printf("Couldn't add edges %d %d\n", edges, count); goto pattern_name_free; } } /* Create a Graph */ gconf.socket_id = SOCKET_ID_ANY; gconf.nb_node_patterns = graph_data->nb_nodes; gconf.node_patterns = (const char **)(uintptr_t)node_patterns; graph_id = rte_graph_create(gname, &gconf); if (graph_id == RTE_GRAPH_ID_INVALID) { printf("Graph creation failed with error = %d\n", rte_errno); goto pattern_name_free; } graph_data->graph_id = graph_id; free(node_map); for (i = 0; i < graph_data->nb_nodes; i++) free(node_patterns[i]); free(snk_nodes); free(src_nodes); free(node_patterns); return 0; pattern_name_free: free(node_map); for (i = 0; i < graph_data->nb_nodes; i++) free(node_patterns[i]); snk_free: free(snk_nodes); src_free: free(src_nodes); pattern_free: free(node_patterns); data_free: free(graph_data->node_data); memzone_free: rte_memzone_free(mz); return -ENOMEM; } /* Worker thread function */ static int _graph_perf_wrapper(void *args) { struct graph_lcore_data *data = args; struct rte_graph *graph; /* Lookup graph */ graph = rte_graph_lookup(rte_graph_id_to_name(data->graph_id)); /* Graph walk until done */ while (!data->done) rte_graph_walk(graph); return 0; } static int measure_perf_get(rte_graph_t graph_id) { const char *pattern = rte_graph_id_to_name(graph_id); uint32_t lcore_id = rte_get_next_lcore(-1, 1, 0); struct rte_graph_cluster_stats_param param; struct rte_graph_cluster_stats *stats; struct graph_lcore_data *data; data = rte_zmalloc("Graph_perf", sizeof(struct graph_lcore_data), RTE_CACHE_LINE_SIZE); data->graph_id = graph_id; data->done = 0; /* Run graph worker thread function */ rte_eal_remote_launch(_graph_perf_wrapper, data, lcore_id); /* Collect stats for few msecs */ if (rte_graph_has_stats_feature()) { memset(¶m, 0, sizeof(param)); param.f = stdout; param.socket_id = SOCKET_ID_ANY; param.graph_patterns = &pattern; param.nb_graph_patterns = 1; stats = rte_graph_cluster_stats_create(¶m); if (stats == NULL) { printf("Failed to create stats\n"); return -ENOMEM; } rte_delay_ms(3E2); rte_graph_cluster_stats_get(stats, true); rte_delay_ms(1E3); rte_graph_cluster_stats_get(stats, false); rte_graph_cluster_stats_destroy(stats); } else rte_delay_ms(1E3); data->done = 1; rte_eal_wait_lcore(lcore_id); return 0; } static inline void graph_fini(void) { const struct rte_memzone *mz = rte_memzone_lookup(TEST_GRAPH_PERF_MZ); struct test_graph_perf *graph_data; if (mz == NULL) return; graph_data = mz->addr; rte_graph_destroy(graph_data->graph_id); free(graph_data->node_data); rte_memzone_free(rte_memzone_lookup(TEST_GRAPH_PERF_MZ)); } static int measure_perf(void) { const struct rte_memzone *mz; struct test_graph_perf *graph_data; mz = rte_memzone_lookup(TEST_GRAPH_PERF_MZ); if (mz == NULL) return -ENOMEM; graph_data = mz->addr; return measure_perf_get(graph_data->graph_id); } static inline int graph_hr_4s_1n_1src_1snk(void) { return measure_perf(); } static inline int graph_hr_4s_1n_1src_1snk_brst_one(void) { return measure_perf(); } static inline int graph_hr_4s_1n_2src_1snk(void) { return measure_perf(); } static inline int graph_hr_4s_1n_1src_2snk(void) { return measure_perf(); } static inline int graph_tree_4s_4n_1src_4snk(void) { return measure_perf(); } static inline int graph_reverse_tree_3s_4n_1src_1snk(void) { return measure_perf(); } static inline int graph_parallel_tree_5s_4n_4src_4snk(void) { return measure_perf(); } /* Graph Topology * nodes per stage: 1 * stages: 4 * src: 1 * sink: 1 */ static inline int graph_init_hr(void) { uint8_t edge_map[][1][1] = { { {100} }, { {100} }, { {100} }, { {100} }, }; uint8_t src_map[][1] = { {100} }; uint8_t snk_map[][1] = { {100} }; return graph_init("graph_hr", SOURCES(src_map), SINKS(snk_map), STAGES(edge_map), NODES_PER_STAGE(edge_map), src_map, snk_map, edge_map, 0); } /* Graph Topology * nodes per stage: 1 * stages: 4 * src: 1 * sink: 1 */ static inline int graph_init_hr_brst_one(void) { uint8_t edge_map[][1][1] = { { {100} }, { {100} }, { {100} }, { {100} }, }; uint8_t src_map[][1] = { {100} }; uint8_t snk_map[][1] = { {100} }; return graph_init("graph_hr", SOURCES(src_map), SINKS(snk_map), STAGES(edge_map), NODES_PER_STAGE(edge_map), src_map, snk_map, edge_map, 1); } /* Graph Topology * nodes per stage: 1 * stages: 4 * src: 2 * sink: 1 */ static inline int graph_init_hr_multi_src(void) { uint8_t edge_map[][1][1] = { { {100} }, { {100} }, { {100} }, { {100} }, }; uint8_t src_map[][1] = { {100}, {100} }; uint8_t snk_map[][1] = { {100} }; return graph_init("graph_hr", SOURCES(src_map), SINKS(snk_map), STAGES(edge_map), NODES_PER_STAGE(edge_map), src_map, snk_map, edge_map, 0); } /* Graph Topology * nodes per stage: 1 * stages: 4 * src: 1 * sink: 2 */ static inline int graph_init_hr_multi_snk(void) { uint8_t edge_map[][1][1] = { { {100} }, { {100} }, { {100} }, { {100} }, }; uint8_t src_map[][1] = { {100} }; uint8_t snk_map[][2] = { {50, 50} }; return graph_init("graph_hr", SOURCES(src_map), SINKS(snk_map), STAGES(edge_map), NODES_PER_STAGE(edge_map), src_map, snk_map, edge_map, 0); } /* Graph Topology * nodes per stage: 4 * stages: 4 * src: 1 * sink: 4 */ static inline int graph_init_tree(void) { uint8_t edge_map[][4][4] = { { {100, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0} }, { {50, 0, 0, 0}, {50, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0} }, { {33, 33, 0, 0}, {34, 34, 0, 0}, {33, 33, 0, 0}, {0, 0, 0, 0} }, { {25, 25, 25, 0}, {25, 25, 25, 0}, {25, 25, 25, 0}, {25, 25, 25, 0} } }; uint8_t src_map[][4] = { {100, 0, 0, 0} }; uint8_t snk_map[][4] = { {100, 0, 0, 0}, {0, 100, 0, 0}, {0, 0, 100, 0}, {0, 0, 0, 100} }; return graph_init("graph_full_split", SOURCES(src_map), SINKS(snk_map), STAGES(edge_map), NODES_PER_STAGE(edge_map), src_map, snk_map, edge_map, 0); } /* Graph Topology * nodes per stage: 4 * stages: 3 * src: 1 * sink: 1 */ static inline int graph_init_reverse_tree(void) { uint8_t edge_map[][4][4] = { { {25, 25, 25, 25}, {25, 25, 25, 25}, {25, 25, 25, 25}, {25, 25, 25, 25} }, { {33, 33, 33, 33}, {33, 33, 33, 33}, {34, 34, 34, 34}, {0, 0, 0, 0} }, { {50, 50, 50, 0}, {50, 50, 50, 0}, {0, 0, 0, 0}, {0, 0, 0, 0} }, }; uint8_t src_map[][4] = { {25, 25, 25, 25} }; uint8_t snk_map[][1] = { {100}, {100}, {0}, {0} }; return graph_init("graph_full_split", SOURCES(src_map), SINKS(snk_map), STAGES(edge_map), NODES_PER_STAGE(edge_map), src_map, snk_map, edge_map, 0); } /* Graph Topology * nodes per stage: 4 * stages: 5 * src: 4 * sink: 4 */ static inline int graph_init_parallel_tree(void) { uint8_t edge_map[][4][4] = { { {100, 0, 0, 0}, {0, 100, 0, 0}, {0, 0, 100, 0}, {0, 0, 0, 100} }, { {100, 0, 0, 0}, {0, 100, 0, 0}, {0, 0, 100, 0}, {0, 0, 0, 100} }, { {100, 0, 0, 0}, {0, 100, 0, 0}, {0, 0, 100, 0}, {0, 0, 0, 100} }, { {100, 0, 0, 0}, {0, 100, 0, 0}, {0, 0, 100, 0}, {0, 0, 0, 100} }, { {100, 0, 0, 0}, {0, 100, 0, 0}, {0, 0, 100, 0}, {0, 0, 0, 100} }, }; uint8_t src_map[][4] = { {100, 0, 0, 0}, {0, 100, 0, 0}, {0, 0, 100, 0}, {0, 0, 0, 100} }; uint8_t snk_map[][4] = { {100, 0, 0, 0}, {0, 100, 0, 0}, {0, 0, 100, 0}, {0, 0, 0, 100} }; return graph_init("graph_parallel", SOURCES(src_map), SINKS(snk_map), STAGES(edge_map), NODES_PER_STAGE(edge_map), src_map, snk_map, edge_map, 0); } /** Graph Creation cheat sheet * edge_map -> dictates graph flow from worker stage 0 to worker stage n-1. * src_map -> dictates source nodes enqueue percentage to worker stage 0. * snk_map -> dictates stage n-1 enqueue percentage to sink. * * Layout: * edge_map[<nb_stages>][<nodes_per_stg>][<nodes_in_nxt_stg = nodes_per_stg>] * src_map[<nb_sources>][<nodes_in_stage0 = nodes_per_stage>] * snk_map[<nodes_in_stage(n-1) = nodes_per_stage>][<nb_sinks>] * * The last array dictates the percentage of received objs to enqueue to next * stage. * * Note: edge_map[][0][] will always be unused as it will receive from source * * Example: * Graph: * http://bit.ly/2PqbqOy * Each stage(n) connects to all nodes in the next stage in decreasing * order. * Since we can't resize the edge_map dynamically we get away by creating * dummy nodes and assigning 0 percentages. * Max nodes across all stages = 4 * stages = 3 * nb_src = 1 * nb_snk = 1 * // Stages * edge_map[][4][4] = { * // Nodes per stage * { * {25, 25, 25, 25}, * {25, 25, 25, 25}, * {25, 25, 25, 25}, * {25, 25, 25, 25} * }, // This will be unused. * { * // Nodes enabled in current stage + prev stage enq % * {33, 33, 33, 33}, * {33, 33, 33, 33}, * {34, 34, 34, 34}, * {0, 0, 0, 0} * }, * { * {50, 50, 50, 0}, * {50, 50, 50, 0}, * {0, 0, 0, 0}, * {0, 0, 0, 0} * }, * }; * Above, each stage tells how much it should receive from previous except * from stage_0. * * src_map[][4] = { {25, 25, 25, 25} }; * Here, we tell each source the % it has to send to stage_0 nodes. In * case we want 2 source node we can declare as * src_map[][4] = { {25, 25, 25, 25}, {25, 25, 25, 25} }; * * snk_map[][1] = { {100}, {100}, {0}, {0} } * Here, we tell stage - 1 nodes how much to enqueue to sink_0. * If we have 2 sinks we can do as follows * snk_map[][2] = { {50, 50}, {50, 50}, {0, 0}, {0, 0} } */ static struct unit_test_suite graph_perf_testsuite = { .suite_name = "Graph library performance test suite", .setup = graph_perf_setup, .teardown = graph_perf_teardown, .unit_test_cases = { TEST_CASE_ST(graph_init_hr, graph_fini, graph_hr_4s_1n_1src_1snk), TEST_CASE_ST(graph_init_hr_brst_one, graph_fini, graph_hr_4s_1n_1src_1snk_brst_one), TEST_CASE_ST(graph_init_hr_multi_src, graph_fini, graph_hr_4s_1n_2src_1snk), TEST_CASE_ST(graph_init_hr_multi_snk, graph_fini, graph_hr_4s_1n_1src_2snk), TEST_CASE_ST(graph_init_tree, graph_fini, graph_tree_4s_4n_1src_4snk), TEST_CASE_ST(graph_init_reverse_tree, graph_fini, graph_reverse_tree_3s_4n_1src_1snk), TEST_CASE_ST(graph_init_parallel_tree, graph_fini, graph_parallel_tree_5s_4n_4src_4snk), TEST_CASES_END(), /**< NULL terminate unit test array */ }, }; static int test_graph_perf_func(void) { return unit_test_suite_runner(&graph_perf_testsuite); } #endif /* !RTE_EXEC_ENV_WINDOWS */ REGISTER_PERF_TEST(graph_perf_autotest, test_graph_perf_func);