1 /*
2 * rcutorture.c: simple user-level performance/stress test of RCU.
3 *
4 * Usage:
5 * ./rcu <nreaders> rperf [ <seconds> ]
6 * Run a read-side performance test with the specified
7 * number of readers for <seconds> seconds.
8 * ./rcu <nupdaters> uperf [ <seconds> ]
9 * Run an update-side performance test with the specified
10 * number of updaters and specified duration.
11 * ./rcu <nreaders> perf [ <seconds> ]
12 * Run a combined read/update performance test with the specified
13 * number of readers and one updater and specified duration.
14 *
15 * The above tests produce output as follows:
16 *
17 * n_reads: 46008000 n_updates: 146026 nreaders: 2 nupdaters: 1 duration: 1
18 * ns/read: 43.4707 ns/update: 6848.1
19 *
20 * The first line lists the total number of RCU reads and updates executed
21 * during the test, the number of reader threads, the number of updater
22 * threads, and the duration of the test in seconds. The second line
23 * lists the average duration of each type of operation in nanoseconds,
24 * or "nan" if the corresponding type of operation was not performed.
25 *
26 * ./rcu <nreaders> stress [ <seconds> ]
27 * Run a stress test with the specified number of readers and
28 * one updater.
29 *
30 * This test produces output as follows:
31 *
32 * n_reads: 114633217 n_updates: 3903415 n_mberror: 0
33 * rcu_stress_count: 114618391 14826 0 0 0 0 0 0 0 0 0
34 *
35 * The first line lists the number of RCU read and update operations
36 * executed, followed by the number of memory-ordering violations
37 * (which will be zero in a correct RCU implementation). The second
38 * line lists the number of readers observing progressively more stale
39 * data. A correct RCU implementation will have all but the first two
40 * numbers non-zero.
41 *
42 * This program is free software; you can redistribute it and/or modify
43 * it under the terms of the GNU General Public License as published by
44 * the Free Software Foundation; either version 2 of the License, or
45 * (at your option) any later version.
46 *
47 * This program is distributed in the hope that it will be useful,
48 * but WITHOUT ANY WARRANTY; without even the implied warranty of
49 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
50 * GNU General Public License for more details.
51 *
52 * You should have received a copy of the GNU General Public License
53 * along with this program. If not, see <https://www.gnu.org/licenses/>.
54 *
55 * Copyright (c) 2008 Paul E. McKenney, IBM Corporation.
56 */
57
58 /*
59 * Test variables.
60 */
61
62 #include "qemu/osdep.h"
63 #include "qemu/atomic.h"
64 #include "qemu/rcu.h"
65 #include "qemu/thread.h"
66
67 int nthreadsrunning;
68
69 #define GOFLAG_INIT 0
70 #define GOFLAG_RUN 1
71 #define GOFLAG_STOP 2
72
73 static volatile int goflag = GOFLAG_INIT;
74
75 #define RCU_READ_RUN 1000
76
77 #define NR_THREADS 100
78 static QemuThread threads[NR_THREADS];
79 static struct rcu_reader_data *data[NR_THREADS];
80 static int n_threads;
81
82 /*
83 * Statistical counts
84 *
85 * These are the sum of local counters at the end of a run.
86 * Updates are protected by a mutex.
87 */
88 static QemuMutex counts_mutex;
89 long long n_reads = 0LL;
90 long n_updates = 0L;
91
create_thread(void * (* func)(void *))92 static void create_thread(void *(*func)(void *))
93 {
94 if (n_threads >= NR_THREADS) {
95 fprintf(stderr, "Thread limit of %d exceeded!\n", NR_THREADS);
96 exit(-1);
97 }
98 qemu_thread_create(&threads[n_threads], "test", func, &data[n_threads],
99 QEMU_THREAD_JOINABLE);
100 n_threads++;
101 }
102
wait_all_threads(void)103 static void wait_all_threads(void)
104 {
105 int i;
106
107 for (i = 0; i < n_threads; i++) {
108 qemu_thread_join(&threads[i]);
109 }
110 n_threads = 0;
111 }
112
113 /*
114 * Performance test.
115 */
116
rcu_read_perf_test(void * arg)117 static void *rcu_read_perf_test(void *arg)
118 {
119 int i;
120 long long n_reads_local = 0;
121
122 rcu_register_thread();
123
124 *(struct rcu_reader_data **)arg = get_ptr_rcu_reader();
125 qatomic_inc(&nthreadsrunning);
126 while (goflag == GOFLAG_INIT) {
127 g_usleep(1000);
128 }
129 while (goflag == GOFLAG_RUN) {
130 for (i = 0; i < RCU_READ_RUN; i++) {
131 rcu_read_lock();
132 rcu_read_unlock();
133 }
134 n_reads_local += RCU_READ_RUN;
135 }
136 qemu_mutex_lock(&counts_mutex);
137 n_reads += n_reads_local;
138 qemu_mutex_unlock(&counts_mutex);
139
140 rcu_unregister_thread();
141 return NULL;
142 }
143
rcu_update_perf_test(void * arg)144 static void *rcu_update_perf_test(void *arg)
145 {
146 long long n_updates_local = 0;
147
148 rcu_register_thread();
149
150 *(struct rcu_reader_data **)arg = get_ptr_rcu_reader();
151 qatomic_inc(&nthreadsrunning);
152 while (goflag == GOFLAG_INIT) {
153 g_usleep(1000);
154 }
155 while (goflag == GOFLAG_RUN) {
156 synchronize_rcu();
157 n_updates_local++;
158 }
159 qemu_mutex_lock(&counts_mutex);
160 n_updates += n_updates_local;
161 qemu_mutex_unlock(&counts_mutex);
162
163 rcu_unregister_thread();
164 return NULL;
165 }
166
perftestinit(void)167 static void perftestinit(void)
168 {
169 nthreadsrunning = 0;
170 }
171
perftestrun(int nthreads,int duration,int nreaders,int nupdaters)172 static void perftestrun(int nthreads, int duration, int nreaders, int nupdaters)
173 {
174 while (qatomic_read(&nthreadsrunning) < nthreads) {
175 g_usleep(1000);
176 }
177 goflag = GOFLAG_RUN;
178 g_usleep(duration * G_USEC_PER_SEC);
179 goflag = GOFLAG_STOP;
180 wait_all_threads();
181 printf("n_reads: %lld n_updates: %ld nreaders: %d nupdaters: %d duration: %d\n",
182 n_reads, n_updates, nreaders, nupdaters, duration);
183 printf("ns/read: %g ns/update: %g\n",
184 ((duration * 1000*1000*1000.*(double)nreaders) /
185 (double)n_reads),
186 ((duration * 1000*1000*1000.*(double)nupdaters) /
187 (double)n_updates));
188 exit(0);
189 }
190
perftest(int nreaders,int duration)191 static void perftest(int nreaders, int duration)
192 {
193 int i;
194
195 perftestinit();
196 for (i = 0; i < nreaders; i++) {
197 create_thread(rcu_read_perf_test);
198 }
199 create_thread(rcu_update_perf_test);
200 perftestrun(i + 1, duration, nreaders, 1);
201 }
202
rperftest(int nreaders,int duration)203 static void rperftest(int nreaders, int duration)
204 {
205 int i;
206
207 perftestinit();
208 for (i = 0; i < nreaders; i++) {
209 create_thread(rcu_read_perf_test);
210 }
211 perftestrun(i, duration, nreaders, 0);
212 }
213
uperftest(int nupdaters,int duration)214 static void uperftest(int nupdaters, int duration)
215 {
216 int i;
217
218 perftestinit();
219 for (i = 0; i < nupdaters; i++) {
220 create_thread(rcu_update_perf_test);
221 }
222 perftestrun(i, duration, 0, nupdaters);
223 }
224
225 /*
226 * Stress test.
227 */
228
229 #define RCU_STRESS_PIPE_LEN 10
230
231 struct rcu_stress {
232 int age; /* how many update cycles while not rcu_stress_current */
233 int mbtest;
234 };
235
236 struct rcu_stress rcu_stress_array[RCU_STRESS_PIPE_LEN] = { { 0 } };
237 struct rcu_stress *rcu_stress_current;
238 int n_mberror;
239
240 /* Updates protected by counts_mutex */
241 long long rcu_stress_count[RCU_STRESS_PIPE_LEN + 1];
242
243
rcu_read_stress_test(void * arg)244 static void *rcu_read_stress_test(void *arg)
245 {
246 int i;
247 struct rcu_stress *p;
248 int pc;
249 long long n_reads_local = 0;
250 long long rcu_stress_local[RCU_STRESS_PIPE_LEN + 1] = { 0 };
251 volatile int garbage = 0;
252
253 rcu_register_thread();
254
255 *(struct rcu_reader_data **)arg = get_ptr_rcu_reader();
256 while (goflag == GOFLAG_INIT) {
257 g_usleep(1000);
258 }
259 while (goflag == GOFLAG_RUN) {
260 rcu_read_lock();
261 p = qatomic_rcu_read(&rcu_stress_current);
262 if (qatomic_read(&p->mbtest) == 0) {
263 n_mberror++;
264 }
265 rcu_read_lock();
266 for (i = 0; i < 100; i++) {
267 garbage++;
268 }
269 rcu_read_unlock();
270 pc = qatomic_read(&p->age);
271 rcu_read_unlock();
272 if ((pc > RCU_STRESS_PIPE_LEN) || (pc < 0)) {
273 pc = RCU_STRESS_PIPE_LEN;
274 }
275 rcu_stress_local[pc]++;
276 n_reads_local++;
277 }
278 qemu_mutex_lock(&counts_mutex);
279 n_reads += n_reads_local;
280 for (i = 0; i <= RCU_STRESS_PIPE_LEN; i++) {
281 rcu_stress_count[i] += rcu_stress_local[i];
282 }
283 qemu_mutex_unlock(&counts_mutex);
284
285 rcu_unregister_thread();
286 return NULL;
287 }
288
289 /*
290 * Stress Test Updater
291 *
292 * The updater cycles around updating rcu_stress_current to point at
293 * one of the rcu_stress_array_entries and resets it's age. It
294 * then increments the age of all the other entries. The age
295 * will be read under an rcu_read_lock() and distribution of values
296 * calculated. The final result gives an indication of how many
297 * previously current rcu_stress entries are in flight until the RCU
298 * cycle complete.
299 */
rcu_update_stress_test(void * arg)300 static void *rcu_update_stress_test(void *arg)
301 {
302 int i, rcu_stress_idx = 0;
303 struct rcu_stress *cp = qatomic_read(&rcu_stress_current);
304
305 rcu_register_thread();
306 *(struct rcu_reader_data **)arg = get_ptr_rcu_reader();
307
308 while (goflag == GOFLAG_INIT) {
309 g_usleep(1000);
310 }
311
312 while (goflag == GOFLAG_RUN) {
313 struct rcu_stress *p;
314 rcu_stress_idx++;
315 if (rcu_stress_idx >= RCU_STRESS_PIPE_LEN) {
316 rcu_stress_idx = 0;
317 }
318 p = &rcu_stress_array[rcu_stress_idx];
319 /* catching up with ourselves would be a bug */
320 assert(p != cp);
321 qatomic_set(&p->mbtest, 0);
322 smp_mb();
323 qatomic_set(&p->age, 0);
324 qatomic_set(&p->mbtest, 1);
325 qatomic_rcu_set(&rcu_stress_current, p);
326 cp = p;
327 /*
328 * New RCU structure is now live, update pipe counts on old
329 * ones.
330 */
331 for (i = 0; i < RCU_STRESS_PIPE_LEN; i++) {
332 if (i != rcu_stress_idx) {
333 qatomic_set(&rcu_stress_array[i].age,
334 rcu_stress_array[i].age + 1);
335 }
336 }
337 synchronize_rcu();
338 n_updates++;
339 }
340
341 rcu_unregister_thread();
342 return NULL;
343 }
344
rcu_fake_update_stress_test(void * arg)345 static void *rcu_fake_update_stress_test(void *arg)
346 {
347 rcu_register_thread();
348
349 *(struct rcu_reader_data **)arg = get_ptr_rcu_reader();
350 while (goflag == GOFLAG_INIT) {
351 g_usleep(1000);
352 }
353 while (goflag == GOFLAG_RUN) {
354 synchronize_rcu();
355 g_usleep(1000);
356 }
357
358 rcu_unregister_thread();
359 return NULL;
360 }
361
stresstest(int nreaders,int duration)362 static void stresstest(int nreaders, int duration)
363 {
364 int i;
365
366 rcu_stress_current = &rcu_stress_array[0];
367 rcu_stress_current->age = 0;
368 rcu_stress_current->mbtest = 1;
369 for (i = 0; i < nreaders; i++) {
370 create_thread(rcu_read_stress_test);
371 }
372 create_thread(rcu_update_stress_test);
373 for (i = 0; i < 5; i++) {
374 create_thread(rcu_fake_update_stress_test);
375 }
376 goflag = GOFLAG_RUN;
377 g_usleep(duration * G_USEC_PER_SEC);
378 goflag = GOFLAG_STOP;
379 wait_all_threads();
380 printf("n_reads: %lld n_updates: %ld n_mberror: %d\n",
381 n_reads, n_updates, n_mberror);
382 printf("rcu_stress_count:");
383 for (i = 0; i <= RCU_STRESS_PIPE_LEN; i++) {
384 printf(" %lld", rcu_stress_count[i]);
385 }
386 printf("\n");
387 exit(0);
388 }
389
390 /* GTest interface */
391
gtest_stress(int nreaders,int duration)392 static void gtest_stress(int nreaders, int duration)
393 {
394 int i;
395
396 rcu_stress_current = &rcu_stress_array[0];
397 rcu_stress_current->age = 0;
398 rcu_stress_current->mbtest = 1;
399 for (i = 0; i < nreaders; i++) {
400 create_thread(rcu_read_stress_test);
401 }
402 create_thread(rcu_update_stress_test);
403 for (i = 0; i < 5; i++) {
404 create_thread(rcu_fake_update_stress_test);
405 }
406 goflag = GOFLAG_RUN;
407 g_usleep(duration * G_USEC_PER_SEC);
408 goflag = GOFLAG_STOP;
409 wait_all_threads();
410 g_assert_cmpint(n_mberror, ==, 0);
411 for (i = 2; i <= RCU_STRESS_PIPE_LEN; i++) {
412 g_assert_cmpint(rcu_stress_count[i], ==, 0);
413 }
414 }
415
gtest_stress_1_1(void)416 static void gtest_stress_1_1(void)
417 {
418 gtest_stress(1, 1);
419 }
420
gtest_stress_10_1(void)421 static void gtest_stress_10_1(void)
422 {
423 gtest_stress(10, 1);
424 }
425
gtest_stress_1_5(void)426 static void gtest_stress_1_5(void)
427 {
428 gtest_stress(1, 5);
429 }
430
gtest_stress_10_5(void)431 static void gtest_stress_10_5(void)
432 {
433 gtest_stress(10, 5);
434 }
435
436 /*
437 * Mainprogram.
438 */
439
usage(int argc,char * argv[])440 static void usage(int argc, char *argv[])
441 {
442 fprintf(stderr, "Usage: %s [nreaders [ [r|u]perf | stress [duration]]\n",
443 argv[0]);
444 exit(-1);
445 }
446
main(int argc,char * argv[])447 int main(int argc, char *argv[])
448 {
449 int nreaders = 1;
450 int duration = 1;
451
452 qemu_mutex_init(&counts_mutex);
453 if (argc >= 2 && argv[1][0] == '-') {
454 g_test_init(&argc, &argv, NULL);
455 if (g_test_quick()) {
456 g_test_add_func("/rcu/torture/1reader", gtest_stress_1_1);
457 g_test_add_func("/rcu/torture/10readers", gtest_stress_10_1);
458 } else {
459 g_test_add_func("/rcu/torture/1reader", gtest_stress_1_5);
460 g_test_add_func("/rcu/torture/10readers", gtest_stress_10_5);
461 }
462 return g_test_run();
463 }
464
465 if (argc >= 2) {
466 nreaders = strtoul(argv[1], NULL, 0);
467 }
468 if (argc > 3) {
469 duration = strtoul(argv[3], NULL, 0);
470 }
471 if (argc < 3 || strcmp(argv[2], "stress") == 0) {
472 stresstest(nreaders, duration);
473 } else if (strcmp(argv[2], "rperf") == 0) {
474 rperftest(nreaders, duration);
475 } else if (strcmp(argv[2], "uperf") == 0) {
476 uperftest(nreaders, duration);
477 } else if (strcmp(argv[2], "perf") == 0) {
478 perftest(nreaders, duration);
479 }
480 usage(argc, argv);
481 return 0;
482 }
483