[ceph.git] / ceph / src / spdk / dpdk / app / test / test_fib_perf.c

/* SPDX-License-Identifier: BSD-3-Clause
 * Copyright(c) 2018 Vladimir Medvedkin <medvedkinv@gmail.com>
 * Copyright(c) 2019 Intel Corporation
 */

#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <math.h>

#include <rte_cycles.h>
#include <rte_random.h>
#include <rte_branch_prediction.h>
#include <rte_ip.h>
#include <rte_fib.h>

#include "test.h"
#include "test_xmmt_ops.h"

#define TEST_FIB_ASSERT(cond) do {				\
	if (!(cond)) {						\
		printf("Error at line %d:\n", __LINE__);	\
		return -1;					\
	}                                                       \
} while (0)

#define ITERATIONS (1 << 10)
#define BATCH_SIZE (1 << 12)
#define BULK_SIZE 32

#define MAX_RULE_NUM (1200000)

struct route_rule {
	uint32_t ip;
	uint8_t depth;
};

static struct route_rule large_route_table[MAX_RULE_NUM];

static uint32_t num_route_entries;
#define NUM_ROUTE_ENTRIES num_route_entries

enum {
	IP_CLASS_A,
	IP_CLASS_B,
	IP_CLASS_C
};
#define RTE_FIB_MAX_DEPTH	32
/* struct route_rule_count defines the total number of rules in following a/b/c
 * each item in a[]/b[]/c[] is the number of common IP address class A/B/C, not
 * including the ones for private local network.
 */
struct route_rule_count {
	uint32_t a[RTE_FIB_MAX_DEPTH];
	uint32_t b[RTE_FIB_MAX_DEPTH];
	uint32_t c[RTE_FIB_MAX_DEPTH];
};

/* All following numbers of each depth of each common IP class are just
 * got from previous large constant table in app/test/test_lpm_routes.h .
 * In order to match similar performance, they keep same depth and IP
 * address coverage as previous constant table. These numbers don't
 * include any private local IP address. As previous large const rule
 * table was just dumped from a real router, there are no any IP address
 * in class C or D.
 */
static struct route_rule_count rule_count = {
	.a = { /* IP class A in which the most significant bit is 0 */
		    0, /* depth =  1 */
		    0, /* depth =  2 */
		    1, /* depth =  3 */
		    0, /* depth =  4 */
		    2, /* depth =  5 */
		    1, /* depth =  6 */
		    3, /* depth =  7 */
		  185, /* depth =  8 */
		   26, /* depth =  9 */
		   16, /* depth = 10 */
		   39, /* depth = 11 */
		  144, /* depth = 12 */
		  233, /* depth = 13 */
		  528, /* depth = 14 */
		  866, /* depth = 15 */
		 3856, /* depth = 16 */
		 3268, /* depth = 17 */
		 5662, /* depth = 18 */
		17301, /* depth = 19 */
		22226, /* depth = 20 */
		11147, /* depth = 21 */
		16746, /* depth = 22 */
		17120, /* depth = 23 */
		77578, /* depth = 24 */
		  401, /* depth = 25 */
		  656, /* depth = 26 */
		 1107, /* depth = 27 */
		 1121, /* depth = 28 */
		 2316, /* depth = 29 */
		  717, /* depth = 30 */
		   10, /* depth = 31 */
		   66  /* depth = 32 */
	},
	.b = { /* IP class A in which the most 2 significant bits are 10 */
		    0, /* depth =  1 */
		    0, /* depth =  2 */
		    0, /* depth =  3 */
		    0, /* depth =  4 */
		    1, /* depth =  5 */
		    1, /* depth =  6 */
		    1, /* depth =  7 */
		    3, /* depth =  8 */
		    3, /* depth =  9 */
		   30, /* depth = 10 */
		   25, /* depth = 11 */
		  168, /* depth = 12 */
		  305, /* depth = 13 */
		  569, /* depth = 14 */
		 1129, /* depth = 15 */
		50800, /* depth = 16 */
		 1645, /* depth = 17 */
		 1820, /* depth = 18 */
		 3506, /* depth = 19 */
		 3258, /* depth = 20 */
		 3424, /* depth = 21 */
		 4971, /* depth = 22 */
		 6885, /* depth = 23 */
		39771, /* depth = 24 */
		  424, /* depth = 25 */
		  170, /* depth = 26 */
		  433, /* depth = 27 */
		   92, /* depth = 28 */
		  366, /* depth = 29 */
		  377, /* depth = 30 */
		    2, /* depth = 31 */
		  200  /* depth = 32 */
	},
	.c = { /* IP class A in which the most 3 significant bits are 110 */
		     0, /* depth =  1 */
		     0, /* depth =  2 */
		     0, /* depth =  3 */
		     0, /* depth =  4 */
		     0, /* depth =  5 */
		     0, /* depth =  6 */
		     0, /* depth =  7 */
		    12, /* depth =  8 */
		     8, /* depth =  9 */
		     9, /* depth = 10 */
		    33, /* depth = 11 */
		    69, /* depth = 12 */
		   237, /* depth = 13 */
		  1007, /* depth = 14 */
		  1717, /* depth = 15 */
		 14663, /* depth = 16 */
		  8070, /* depth = 17 */
		 16185, /* depth = 18 */
		 48261, /* depth = 19 */
		 36870, /* depth = 20 */
		 33960, /* depth = 21 */
		 50638, /* depth = 22 */
		 61422, /* depth = 23 */
		466549, /* depth = 24 */
		  1829, /* depth = 25 */
		  4824, /* depth = 26 */
		  4927, /* depth = 27 */
		  5914, /* depth = 28 */
		 10254, /* depth = 29 */
		  4905, /* depth = 30 */
		     1, /* depth = 31 */
		   716  /* depth = 32 */
	}
};

static void generate_random_rule_prefix(uint32_t ip_class, uint8_t depth)
{
/* IP address class A, the most significant bit is 0 */
#define IP_HEAD_MASK_A			0x00000000
#define IP_HEAD_BIT_NUM_A		1

/* IP address class B, the most significant 2 bits are 10 */
#define IP_HEAD_MASK_B			0x80000000
#define IP_HEAD_BIT_NUM_B		2

/* IP address class C, the most significant 3 bits are 110 */
#define IP_HEAD_MASK_C			0xC0000000
#define IP_HEAD_BIT_NUM_C		3

	uint32_t class_depth;
	uint32_t range;
	uint32_t mask;
	uint32_t step;
	uint32_t start;
	uint32_t fixed_bit_num;
	uint32_t ip_head_mask;
	uint32_t rule_num;
	uint32_t k;
	struct route_rule *ptr_rule;

	if (ip_class == IP_CLASS_A) {        /* IP Address class A */
		fixed_bit_num = IP_HEAD_BIT_NUM_A;
		ip_head_mask = IP_HEAD_MASK_A;
		rule_num = rule_count.a[depth - 1];
	} else if (ip_class == IP_CLASS_B) { /* IP Address class B */
		fixed_bit_num = IP_HEAD_BIT_NUM_B;
		ip_head_mask = IP_HEAD_MASK_B;
		rule_num = rule_count.b[depth - 1];
	} else {                             /* IP Address class C */
		fixed_bit_num = IP_HEAD_BIT_NUM_C;
		ip_head_mask = IP_HEAD_MASK_C;
		rule_num = rule_count.c[depth - 1];
	}

	if (rule_num == 0)
		return;

	/* the number of rest bits which don't include the most significant
	 * fixed bits for this IP address class
	 */
	class_depth = depth - fixed_bit_num;

	/* range is the maximum number of rules for this depth and
	 * this IP address class
	 */
	range = 1 << class_depth;

	/* only mask the most depth significant generated bits
	 * except fixed bits for IP address class
	 */
	mask = range - 1;

	/* Widen coverage of IP address in generated rules */
	if (range <= rule_num)
		step = 1;
	else
		step = round((double)range / rule_num);

	/* Only generate rest bits except the most significant
	 * fixed bits for IP address class
	 */
	start = lrand48() & mask;
	ptr_rule = &large_route_table[num_route_entries];
	for (k = 0; k < rule_num; k++) {
		ptr_rule->ip = (start << (RTE_FIB_MAX_DEPTH - depth))
			| ip_head_mask;
		ptr_rule->depth = depth;
		ptr_rule++;
		start = (start + step) & mask;
	}
	num_route_entries += rule_num;
}

static void insert_rule_in_random_pos(uint32_t ip, uint8_t depth)
{
	uint32_t pos;
	int try_count = 0;
	struct route_rule tmp;

	do {
		pos = lrand48();
		try_count++;
	} while ((try_count < 10) && (pos > num_route_entries));

	if ((pos > num_route_entries) || (pos >= MAX_RULE_NUM))
		pos = num_route_entries >> 1;

	tmp = large_route_table[pos];
	large_route_table[pos].ip = ip;
	large_route_table[pos].depth = depth;
	if (num_route_entries < MAX_RULE_NUM)
		large_route_table[num_route_entries++] = tmp;
}

static void generate_large_route_rule_table(void)
{
	uint32_t ip_class;
	uint8_t  depth;

	num_route_entries = 0;
	memset(large_route_table, 0, sizeof(large_route_table));

	for (ip_class = IP_CLASS_A; ip_class <= IP_CLASS_C; ip_class++) {
		for (depth = 1; depth <= RTE_FIB_MAX_DEPTH; depth++)
			generate_random_rule_prefix(ip_class, depth);
	}

	/* Add following rules to keep same as previous large constant table,
	 * they are 4 rules with private local IP address and 1 all-zeros prefix
	 * with depth = 8.
	 */
	insert_rule_in_random_pos(RTE_IPV4(0, 0, 0, 0), 8);
	insert_rule_in_random_pos(RTE_IPV4(10, 2, 23, 147), 32);
	insert_rule_in_random_pos(RTE_IPV4(192, 168, 100, 10), 24);
	insert_rule_in_random_pos(RTE_IPV4(192, 168, 25, 100), 24);
	insert_rule_in_random_pos(RTE_IPV4(192, 168, 129, 124), 32);
}

static void
print_route_distribution(const struct route_rule *table, uint32_t n)
{
	unsigned int i, j;

	printf("Route distribution per prefix width:\n");
	printf("DEPTH    QUANTITY (PERCENT)\n");
	printf("---------------------------\n");

	/* Count depths. */
	for (i = 1; i <= 32; i++) {
		unsigned int depth_counter = 0;
		double percent_hits;

		for (j = 0; j < n; j++)
			if (table[j].depth == (uint8_t) i)
				depth_counter++;

		percent_hits = ((double)depth_counter)/((double)n) * 100;
		printf("%.2u%15u (%.2f)\n", i, depth_counter, percent_hits);
	}
	printf("\n");
}

static int
test_fib_perf(void)
{
	struct rte_fib *fib = NULL;
	struct rte_fib_conf config;

	config.max_routes = 2000000;
	config.type = RTE_FIB_DIR24_8;
	config.default_nh = 0;
	config.dir24_8.nh_sz = RTE_FIB_DIR24_8_4B;
	config.dir24_8.num_tbl8 = 65535;
	uint64_t begin, total_time;
	unsigned int i, j;
	uint32_t next_hop_add = 0xAA;
	int status = 0;
	int64_t count = 0;

	rte_srand(rte_rdtsc());

	generate_large_route_rule_table();

	printf("No. routes = %u\n", (unsigned int) NUM_ROUTE_ENTRIES);

	print_route_distribution(large_route_table,
		(uint32_t) NUM_ROUTE_ENTRIES);

	fib = rte_fib_create(__func__, SOCKET_ID_ANY, &config);
	TEST_FIB_ASSERT(fib != NULL);

	/* Measue add. */
	begin = rte_rdtsc();

	for (i = 0; i < NUM_ROUTE_ENTRIES; i++) {
		if (rte_fib_add(fib, large_route_table[i].ip,
				large_route_table[i].depth, next_hop_add) == 0)
			status++;
	}
	/* End Timer. */
	total_time = rte_rdtsc() - begin;

	printf("Unique added entries = %d\n", status);

	printf("Average FIB Add: %g cycles\n",
			(double)total_time / NUM_ROUTE_ENTRIES);

	/* Measure bulk Lookup */
	total_time = 0;
	count = 0;
	for (i = 0; i < ITERATIONS; i++) {
		static uint32_t ip_batch[BATCH_SIZE];
		uint64_t next_hops[BULK_SIZE];

		/* Create array of random IP addresses */
		for (j = 0; j < BATCH_SIZE; j++)
			ip_batch[j] = rte_rand();

		/* Lookup per batch */
		begin = rte_rdtsc();
		for (j = 0; j < BATCH_SIZE; j += BULK_SIZE) {
			uint32_t k;
			rte_fib_lookup_bulk(fib, &ip_batch[j], next_hops,
				BULK_SIZE);
			for (k = 0; k < BULK_SIZE; k++)
				if (unlikely(!(next_hops[k] != 0)))
					count++;
		}

		total_time += rte_rdtsc() - begin;
	}
	printf("BULK FIB Lookup: %.1f cycles (fails = %.1f%%)\n",
			(double)total_time / ((double)ITERATIONS * BATCH_SIZE),
			(count * 100.0) / (double)(ITERATIONS * BATCH_SIZE));

	/* Delete */
	status = 0;
	begin = rte_rdtsc();
	for (i = 0; i < NUM_ROUTE_ENTRIES; i++) {
		/* rte_lpm_delete(lpm, ip, depth) */
		status += rte_fib_delete(fib, large_route_table[i].ip,
				large_route_table[i].depth);
	}

	total_time += rte_rdtsc() - begin;

	printf("Average FIB Delete: %g cycles\n",
			(double)total_time / NUM_ROUTE_ENTRIES);

	rte_fib_free(fib);

	return 0;
}

REGISTER_TEST_COMMAND(fib_perf_autotest, test_fib_perf);
Commit	Line	Data
f67539c2 TL	1	/* SPDX-License-Identifier: BSD-3-Clause
	2	* Copyright(c) 2018 Vladimir Medvedkin <medvedkinv@gmail.com>
	3	* Copyright(c) 2019 Intel Corporation
	4	*/
	5
	6	#include <stdio.h>
	7	#include <stdint.h>
	8	#include <stdlib.h>
	9	#include <math.h>
	10
	11	#include <rte_cycles.h>
	12	#include <rte_random.h>
	13	#include <rte_branch_prediction.h>
	14	#include <rte_ip.h>
	15	#include <rte_fib.h>
	16
	17	#include "test.h"
	18	#include "test_xmmt_ops.h"
	19
	20	#define TEST_FIB_ASSERT(cond) do { \
	21	if (!(cond)) { \
	22	printf("Error at line %d:\n", __LINE__); \
	23	return -1; \
	24	} \
	25	} while (0)
	26
	27	#define ITERATIONS (1 << 10)
	28	#define BATCH_SIZE (1 << 12)
	29	#define BULK_SIZE 32
	30
	31	#define MAX_RULE_NUM (1200000)
	32
	33	struct route_rule {
	34	uint32_t ip;
	35	uint8_t depth;
	36	};
	37
	38	static struct route_rule large_route_table[MAX_RULE_NUM];
	39
	40	static uint32_t num_route_entries;
	41	#define NUM_ROUTE_ENTRIES num_route_entries
	42
	43	enum {
	44	IP_CLASS_A,
	45	IP_CLASS_B,
	46	IP_CLASS_C
	47	};
	48	#define RTE_FIB_MAX_DEPTH 32
	49	/* struct route_rule_count defines the total number of rules in following a/b/c
	50	* each item in a[]/b[]/c[] is the number of common IP address class A/B/C, not
	51	* including the ones for private local network.
	52	*/
	53	struct route_rule_count {
	54	uint32_t a[RTE_FIB_MAX_DEPTH];
	55	uint32_t b[RTE_FIB_MAX_DEPTH];
	56	uint32_t c[RTE_FIB_MAX_DEPTH];
	57	};
	58
	59	/* All following numbers of each depth of each common IP class are just
	60	* got from previous large constant table in app/test/test_lpm_routes.h .
	61	* In order to match similar performance, they keep same depth and IP
	62	* address coverage as previous constant table. These numbers don't
	63	* include any private local IP address. As previous large const rule
	64	* table was just dumped from a real router, there are no any IP address
65	* in class C or D.
66	*/
67	static struct route_rule_count rule_count = {
68	.a = { /* IP class A in which the most significant bit is 0 */
69	0, /* depth = 1 */
70	0, /* depth = 2 */
71	1, /* depth = 3 */
72	0, /* depth = 4 */
73	2, /* depth = 5 */
74	1, /* depth = 6 */
75	3, /* depth = 7 */
76	185, /* depth = 8 */
77	26, /* depth = 9 */
78	16, /* depth = 10 */
79	39, /* depth = 11 */
80	144, /* depth = 12 */
81	233, /* depth = 13 */
82	528, /* depth = 14 */
83	866, /* depth = 15 */
84	3856, /* depth = 16 */
85	3268, /* depth = 17 */
86	5662, /* depth = 18 */
87	17301, /* depth = 19 */
88	22226, /* depth = 20 */
89	11147, /* depth = 21 */
90	16746, /* depth = 22 */
91	17120, /* depth = 23 */
92	77578, /* depth = 24 */
93	401, /* depth = 25 */
94	656, /* depth = 26 */
95	1107, /* depth = 27 */
96	1121, /* depth = 28 */
97	2316, /* depth = 29 */
98	717, /* depth = 30 */
99	10, /* depth = 31 */
100	66 /* depth = 32 */
101	},
102	.b = { /* IP class A in which the most 2 significant bits are 10 */
103	0, /* depth = 1 */
104	0, /* depth = 2 */
105	0, /* depth = 3 */
106	0, /* depth = 4 */
107	1, /* depth = 5 */
108	1, /* depth = 6 */
109	1, /* depth = 7 */
110	3, /* depth = 8 */
111	3, /* depth = 9 */
112	30, /* depth = 10 */
113	25, /* depth = 11 */
114	168, /* depth = 12 */
115	305, /* depth = 13 */
116	569, /* depth = 14 */
117	1129, /* depth = 15 */
118	50800, /* depth = 16 */
119	1645, /* depth = 17 */
120	1820, /* depth = 18 */
121	3506, /* depth = 19 */
122	3258, /* depth = 20 */
123	3424, /* depth = 21 */
124	4971, /* depth = 22 */
125	6885, /* depth = 23 */
126	39771, /* depth = 24 */
127	424, /* depth = 25 */
128	170, /* depth = 26 */
129	433, /* depth = 27 */
130	92, /* depth = 28 */
131	366, /* depth = 29 */
132	377, /* depth = 30 */
133	2, /* depth = 31 */
134	200 /* depth = 32 */
135	},
136	.c = { /* IP class A in which the most 3 significant bits are 110 */
137	0, /* depth = 1 */
138	0, /* depth = 2 */
139	0, /* depth = 3 */
140	0, /* depth = 4 */
141	0, /* depth = 5 */
142	0, /* depth = 6 */
143	0, /* depth = 7 */
144	12, /* depth = 8 */
145	8, /* depth = 9 */
146	9, /* depth = 10 */
147	33, /* depth = 11 */
148	69, /* depth = 12 */
149	237, /* depth = 13 */
150	1007, /* depth = 14 */
151	1717, /* depth = 15 */
152	14663, /* depth = 16 */
153	8070, /* depth = 17 */
154	16185, /* depth = 18 */
155	48261, /* depth = 19 */
156	36870, /* depth = 20 */
157	33960, /* depth = 21 */
158	50638, /* depth = 22 */
159	61422, /* depth = 23 */
160	466549, /* depth = 24 */
161	1829, /* depth = 25 */
162	4824, /* depth = 26 */
163	4927, /* depth = 27 */
164	5914, /* depth = 28 */
165	10254, /* depth = 29 */
166	4905, /* depth = 30 */
167	1, /* depth = 31 */
168	716 /* depth = 32 */
169	}
170	};
171
172	static void generate_random_rule_prefix(uint32_t ip_class, uint8_t depth)
173	{
174	/* IP address class A, the most significant bit is 0 */
175	#define IP_HEAD_MASK_A 0x00000000
176	#define IP_HEAD_BIT_NUM_A 1
177
178	/* IP address class B, the most significant 2 bits are 10 */
179	#define IP_HEAD_MASK_B 0x80000000
180	#define IP_HEAD_BIT_NUM_B 2
181
182	/* IP address class C, the most significant 3 bits are 110 */
183	#define IP_HEAD_MASK_C 0xC0000000
184	#define IP_HEAD_BIT_NUM_C 3
185
186	uint32_t class_depth;
187	uint32_t range;
188	uint32_t mask;
189	uint32_t step;
190	uint32_t start;
191	uint32_t fixed_bit_num;
192	uint32_t ip_head_mask;
193	uint32_t rule_num;
194	uint32_t k;
195	struct route_rule *ptr_rule;
196
197	if (ip_class == IP_CLASS_A) { /* IP Address class A */
198	fixed_bit_num = IP_HEAD_BIT_NUM_A;
199	ip_head_mask = IP_HEAD_MASK_A;
200	rule_num = rule_count.a[depth - 1];
201	} else if (ip_class == IP_CLASS_B) { /* IP Address class B */
202	fixed_bit_num = IP_HEAD_BIT_NUM_B;
203	ip_head_mask = IP_HEAD_MASK_B;
204	rule_num = rule_count.b[depth - 1];
205	} else { /* IP Address class C */
206	fixed_bit_num = IP_HEAD_BIT_NUM_C;
207	ip_head_mask = IP_HEAD_MASK_C;
208	rule_num = rule_count.c[depth - 1];
209	}
210
211	if (rule_num == 0)
212	return;
213
214	/* the number of rest bits which don't include the most significant
215	* fixed bits for this IP address class
216	*/
217	class_depth = depth - fixed_bit_num;
218
219	/* range is the maximum number of rules for this depth and
220	* this IP address class
221	*/
222	range = 1 << class_depth;
223
224	/* only mask the most depth significant generated bits
225	* except fixed bits for IP address class
226	*/
227	mask = range - 1;
228
229	/* Widen coverage of IP address in generated rules */
230	if (range <= rule_num)
231	step = 1;
232	else
233	step = round((double)range / rule_num);
234
235	/* Only generate rest bits except the most significant
236	* fixed bits for IP address class
237	*/
238	start = lrand48() & mask;
239	ptr_rule = &large_route_table[num_route_entries];
240	for (k = 0; k < rule_num; k++) {
241	ptr_rule->ip = (start << (RTE_FIB_MAX_DEPTH - depth))
242	\| ip_head_mask;
243	ptr_rule->depth = depth;
244	ptr_rule++;
245	start = (start + step) & mask;
246	}
247	num_route_entries += rule_num;
248	}
249
250	static void insert_rule_in_random_pos(uint32_t ip, uint8_t depth)
251	{
252	uint32_t pos;
253	int try_count = 0;
254	struct route_rule tmp;
255
256	do {
257	pos = lrand48();
258	try_count++;
259	} while ((try_count < 10) && (pos > num_route_entries));
260
261	if ((pos > num_route_entries) \|\| (pos >= MAX_RULE_NUM))
262	pos = num_route_entries >> 1;
263
264	tmp = large_route_table[pos];
265	large_route_table[pos].ip = ip;
266	large_route_table[pos].depth = depth;
267	if (num_route_entries < MAX_RULE_NUM)
268	large_route_table[num_route_entries++] = tmp;
269	}
270
271	static void generate_large_route_rule_table(void)
272	{
273	uint32_t ip_class;
274	uint8_t depth;
275
276	num_route_entries = 0;
277	memset(large_route_table, 0, sizeof(large_route_table));
278
279	for (ip_class = IP_CLASS_A; ip_class <= IP_CLASS_C; ip_class++) {
280	for (depth = 1; depth <= RTE_FIB_MAX_DEPTH; depth++)
281	generate_random_rule_prefix(ip_class, depth);
282	}
283
284	/* Add following rules to keep same as previous large constant table,
285	* they are 4 rules with private local IP address and 1 all-zeros prefix
286	* with depth = 8.
287	*/
288	insert_rule_in_random_pos(RTE_IPV4(0, 0, 0, 0), 8);
289	insert_rule_in_random_pos(RTE_IPV4(10, 2, 23, 147), 32);
290	insert_rule_in_random_pos(RTE_IPV4(192, 168, 100, 10), 24);
291	insert_rule_in_random_pos(RTE_IPV4(192, 168, 25, 100), 24);
292	insert_rule_in_random_pos(RTE_IPV4(192, 168, 129, 124), 32);
293	}
294
295	static void
296	print_route_distribution(const struct route_rule *table, uint32_t n)
297	{
298	unsigned int i, j;
299
300	printf("Route distribution per prefix width:\n");
301	printf("DEPTH QUANTITY (PERCENT)\n");
302	printf("---------------------------\n");
303
304	/* Count depths. */
305	for (i = 1; i <= 32; i++) {
306	unsigned int depth_counter = 0;
307	double percent_hits;
308
309	for (j = 0; j < n; j++)
310	if (table[j].depth == (uint8_t) i)
311	depth_counter++;
312
313	percent_hits = ((double)depth_counter)/((double)n) * 100;
314	printf("%.2u%15u (%.2f)\n", i, depth_counter, percent_hits);
315	}
316	printf("\n");
317	}
318
319	static int
320	test_fib_perf(void)
321	{
322	struct rte_fib *fib = NULL;
323	struct rte_fib_conf config;
324
325	config.max_routes = 2000000;
326	config.type = RTE_FIB_DIR24_8;
327	config.default_nh = 0;
328	config.dir24_8.nh_sz = RTE_FIB_DIR24_8_4B;
329	config.dir24_8.num_tbl8 = 65535;
330	uint64_t begin, total_time;
331	unsigned int i, j;
332	uint32_t next_hop_add = 0xAA;
333	int status = 0;
334	int64_t count = 0;
335
336	rte_srand(rte_rdtsc());
337
338	generate_large_route_rule_table();
339
340	printf("No. routes = %u\n", (unsigned int) NUM_ROUTE_ENTRIES);
341
342	print_route_distribution(large_route_table,
343	(uint32_t) NUM_ROUTE_ENTRIES);
344
345	fib = rte_fib_create(__func__, SOCKET_ID_ANY, &config);
346	TEST_FIB_ASSERT(fib != NULL);
347
348	/* Measue add. */
349	begin = rte_rdtsc();
350
351	for (i = 0; i < NUM_ROUTE_ENTRIES; i++) {
352	if (rte_fib_add(fib, large_route_table[i].ip,
353	large_route_table[i].depth, next_hop_add) == 0)
354	status++;
355	}
356	/* End Timer. */
357	total_time = rte_rdtsc() - begin;
358
359	printf("Unique added entries = %d\n", status);
360
361	printf("Average FIB Add: %g cycles\n",
362	(double)total_time / NUM_ROUTE_ENTRIES);
363
364	/* Measure bulk Lookup */
365	total_time = 0;
366	count = 0;
367	for (i = 0; i < ITERATIONS; i++) {
368	static uint32_t ip_batch[BATCH_SIZE];
369	uint64_t next_hops[BULK_SIZE];
370
371	/* Create array of random IP addresses */
372	for (j = 0; j < BATCH_SIZE; j++)
373	ip_batch[j] = rte_rand();
374
375	/* Lookup per batch */
376	begin = rte_rdtsc();
377	for (j = 0; j < BATCH_SIZE; j += BULK_SIZE) {
378	uint32_t k;
379	rte_fib_lookup_bulk(fib, &ip_batch[j], next_hops,
380	BULK_SIZE);
381	for (k = 0; k < BULK_SIZE; k++)
382	if (unlikely(!(next_hops[k] != 0)))
383	count++;
384	}
385
386	total_time += rte_rdtsc() - begin;
387	}
388	printf("BULK FIB Lookup: %.1f cycles (fails = %.1f%%)\n",
389	(double)total_time / ((double)ITERATIONS * BATCH_SIZE),
390	(count * 100.0) / (double)(ITERATIONS * BATCH_SIZE));
391
392	/* Delete */
393	status = 0;
394	begin = rte_rdtsc();
395	for (i = 0; i < NUM_ROUTE_ENTRIES; i++) {
396	/* rte_lpm_delete(lpm, ip, depth) */
397	status += rte_fib_delete(fib, large_route_table[i].ip,
398	large_route_table[i].depth);
399	}
400
401	total_time += rte_rdtsc() - begin;
402
403	printf("Average FIB Delete: %g cycles\n",
404	(double)total_time / NUM_ROUTE_ENTRIES);
405
406	rte_fib_free(fib);
407
408	return 0;
409	}
410
411	REGISTER_TEST_COMMAND(fib_perf_autotest, test_fib_perf);