forked from ~ljy/RK356X_SDK_RELEASE

blame | history | patch | commit | commitdiff
hc
2024-10-22 8ac6c7a54ed1b98d142dce24b11c6de6a1e239a5 
 kernel/tools/testing/radix-tree/benchmark.c
....@@ -1,24 +1,13 @@
1
+// SPDX-License-Identifier: GPL-2.0-only
12 /*
23  * benchmark.c:
34  * Author: Konstantin Khlebnikov <koct9i@gmail.com>
4
- *
5
- * This program is free software; you can redistribute it and/or modify it
6
- * under the terms and conditions of the GNU General Public License,
7
- * version 2, as published by the Free Software Foundation.
8
- *
9
- * This program is distributed in the hope it will be useful, but WITHOUT
10
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11
- * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
12
- * more details.
135  */
146 #include <linux/radix-tree.h>
157 #include <linux/slab.h>
168 #include <linux/errno.h>
179 #include <time.h>
1810 #include "test.h"
19
-
20
-#define for_each_index(i, base, order) \
21
-	        for (i = base; i < base + (1 << order); i++)
2211 
2312 #define NSEC_PER_SEC	1000000000L
2413 
....@@ -61,7 +50,7 @@
6150 }
6251 
6352 static void benchmark_insert(struct radix_tree_root *root,
64
-			     unsigned long size, unsigned long step, int order)
53
+			     unsigned long size, unsigned long step)
6554 {
6655 	struct timespec start, finish;
6756 	unsigned long index;
....@@ -70,19 +59,19 @@
7059 	clock_gettime(CLOCK_MONOTONIC, &start);
7160 
7261 	for (index = 0 ; index < size ; index += step)
73
-		item_insert_order(root, index, order);
62
+		item_insert(root, index);
7463 
7564 	clock_gettime(CLOCK_MONOTONIC, &finish);
7665 
7766 	nsec = (finish.tv_sec - start.tv_sec) * NSEC_PER_SEC +
7867 	       (finish.tv_nsec - start.tv_nsec);
7968 
80
-	printv(2, "Size: %8ld, step: %8ld, order: %d, insertion: %15lld ns\n",
81
-		size, step, order, nsec);
69
+	printv(2, "Size: %8ld, step: %8ld, insertion: %15lld ns\n",
70
+		size, step, nsec);
8271 }
8372 
8473 static void benchmark_tagging(struct radix_tree_root *root,
85
-			     unsigned long size, unsigned long step, int order)
74
+			     unsigned long size, unsigned long step)
8675 {
8776 	struct timespec start, finish;
8877 	unsigned long index;
....@@ -98,136 +87,51 @@
9887 	nsec = (finish.tv_sec - start.tv_sec) * NSEC_PER_SEC +
9988 	       (finish.tv_nsec - start.tv_nsec);
10089 
101
-	printv(2, "Size: %8ld, step: %8ld, order: %d, tagging: %17lld ns\n",
102
-		size, step, order, nsec);
90
+	printv(2, "Size: %8ld, step: %8ld, tagging: %17lld ns\n",
91
+		size, step, nsec);
10392 }
10493 
10594 static void benchmark_delete(struct radix_tree_root *root,
106
-			     unsigned long size, unsigned long step, int order)
95
+			     unsigned long size, unsigned long step)
10796 {
10897 	struct timespec start, finish;
109
-	unsigned long index, i;
98
+	unsigned long index;
11099 	long long nsec;
111100 
112101 	clock_gettime(CLOCK_MONOTONIC, &start);
113102 
114103 	for (index = 0 ; index < size ; index += step)
115
-		for_each_index(i, index, order)
116
-			item_delete(root, i);
104
+		item_delete(root, index);
117105 
118106 	clock_gettime(CLOCK_MONOTONIC, &finish);
119107 
120108 	nsec = (finish.tv_sec - start.tv_sec) * NSEC_PER_SEC +
121109 	       (finish.tv_nsec - start.tv_nsec);
122110 
123
-	printv(2, "Size: %8ld, step: %8ld, order: %d, deletion: %16lld ns\n",
124
-		size, step, order, nsec);
111
+	printv(2, "Size: %8ld, step: %8ld, deletion: %16lld ns\n",
112
+		size, step, nsec);
125113 }
126114 
127
-static void benchmark_size(unsigned long size, unsigned long step, int order)
115
+static void benchmark_size(unsigned long size, unsigned long step)
128116 {
129117 	RADIX_TREE(tree, GFP_KERNEL);
130118 	long long normal, tagged;
131119 
132
-	benchmark_insert(&tree, size, step, order);
133
-	benchmark_tagging(&tree, size, step, order);
120
+	benchmark_insert(&tree, size, step);
121
+	benchmark_tagging(&tree, size, step);
134122 
135123 	tagged = benchmark_iter(&tree, true);
136124 	normal = benchmark_iter(&tree, false);
137125 
138
-	printv(2, "Size: %8ld, step: %8ld, order: %d, tagged iteration: %8lld ns\n",
139
-		size, step, order, tagged);
140
-	printv(2, "Size: %8ld, step: %8ld, order: %d, normal iteration: %8lld ns\n",
141
-		size, step, order, normal);
126
+	printv(2, "Size: %8ld, step: %8ld, tagged iteration: %8lld ns\n",
127
+		size, step, tagged);
128
+	printv(2, "Size: %8ld, step: %8ld, normal iteration: %8lld ns\n",
129
+		size, step, normal);
142130 
143
-	benchmark_delete(&tree, size, step, order);
131
+	benchmark_delete(&tree, size, step);
144132 
145133 	item_kill_tree(&tree);
146134 	rcu_barrier();
147
-}
148
-
149
-static long long  __benchmark_split(unsigned long index,
150
-				    int old_order, int new_order)
151
-{
152
-	struct timespec start, finish;
153
-	long long nsec;
154
-	RADIX_TREE(tree, GFP_ATOMIC);
155
-
156
-	item_insert_order(&tree, index, old_order);
157
-
158
-	clock_gettime(CLOCK_MONOTONIC, &start);
159
-	radix_tree_split(&tree, index, new_order);
160
-	clock_gettime(CLOCK_MONOTONIC, &finish);
161
-	nsec = (finish.tv_sec - start.tv_sec) * NSEC_PER_SEC +
162
-	       (finish.tv_nsec - start.tv_nsec);
163
-
164
-	item_kill_tree(&tree);
165
-
166
-	return nsec;
167
-
168
-}
169
-
170
-static void benchmark_split(unsigned long size, unsigned long step)
171
-{
172
-	int i, j, idx;
173
-	long long nsec = 0;
174
-
175
-
176
-	for (idx = 0; idx < size; idx += step) {
177
-		for (i = 3; i < 11; i++) {
178
-			for (j = 0; j < i; j++) {
179
-				nsec += __benchmark_split(idx, i, j);
180
-			}
181
-		}
182
-	}
183
-
184
-	printv(2, "Size %8ld, step %8ld, split time %10lld ns\n",
185
-			size, step, nsec);
186
-
187
-}
188
-
189
-static long long  __benchmark_join(unsigned long index,
190
-			     unsigned order1, unsigned order2)
191
-{
192
-	unsigned long loc;
193
-	struct timespec start, finish;
194
-	long long nsec;
195
-	void *item, *item2 = item_create(index + 1, order1);
196
-	RADIX_TREE(tree, GFP_KERNEL);
197
-
198
-	item_insert_order(&tree, index, order2);
199
-	item = radix_tree_lookup(&tree, index);
200
-
201
-	clock_gettime(CLOCK_MONOTONIC, &start);
202
-	radix_tree_join(&tree, index + 1, order1, item2);
203
-	clock_gettime(CLOCK_MONOTONIC, &finish);
204
-	nsec = (finish.tv_sec - start.tv_sec) * NSEC_PER_SEC +
205
-		(finish.tv_nsec - start.tv_nsec);
206
-
207
-	loc = find_item(&tree, item);
208
-	if (loc == -1)
209
-		free(item);
210
-
211
-	item_kill_tree(&tree);
212
-
213
-	return nsec;
214
-}
215
-
216
-static void benchmark_join(unsigned long step)
217
-{
218
-	int i, j, idx;
219
-	long long nsec = 0;
220
-
221
-	for (idx = 0; idx < 1 << 10; idx += step) {
222
-		for (i = 1; i < 15; i++) {
223
-			for (j = 0; j < i; j++) {
224
-				nsec += __benchmark_join(idx, i, j);
225
-			}
226
-		}
227
-	}
228
-
229
-	printv(2, "Size %8d, step %8ld, join time %10lld ns\n",
230
-			1 << 10, step, nsec);
231135 }
232136 
233137 void benchmark(void)
....@@ -242,16 +146,5 @@
242146 
243147 	for (c = 0; size[c]; c++)
244148 		for (s = 0; step[s]; s++)
245
-			benchmark_size(size[c], step[s], 0);
246
-
247
-	for (c = 0; size[c]; c++)
248
-		for (s = 0; step[s]; s++)
249
-			benchmark_size(size[c], step[s] << 9, 9);
250
-
251
-	for (c = 0; size[c]; c++)
252
-		for (s = 0; step[s]; s++)
253
-			benchmark_split(size[c], step[s]);
254
-
255
-	for (s = 0; step[s]; s++)
256
-		benchmark_join(step[s]);
149
+			benchmark_size(size[c], step[s]);
257150 }