X-Git-Url: http://git.liburcu.org/?a=blobdiff_plain;f=tests%2Fregression%2Frcutorture.h;h=e20d82eeb15df7873f74e8b795b16f8d111110ec;hb=b21d2eb5c48761a54e6868ed114aa256aee1c2cd;hp=9a2f9a1f581ffc5c34e4ce0c5f2ed2a12e114b75;hpb=447c9339d4f21fe5bba1aa77eccc9f94745e6447;p=urcu.git diff --git a/tests/regression/rcutorture.h b/tests/regression/rcutorture.h index 9a2f9a1..e20d82e 100644 --- a/tests/regression/rcutorture.h +++ b/tests/regression/rcutorture.h @@ -1,3 +1,7 @@ +// SPDX-FileCopyrightText: 2008 Paul E. McKenney, IBM Corporation. +// +// SPDX-License-Identifier: GPL-2.0-or-later + /* * rcutorture.h: simple user-level performance/stress test of RCU. * @@ -43,22 +47,6 @@ * line lists the number of readers observing progressively more stale * data. A correct RCU implementation will have all but the first two * numbers non-zero. - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 2 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Copyright (c) 2008 Paul E. McKenney, IBM Corporation. */ /* @@ -79,6 +67,12 @@ enum callrcu_type { CALLRCU_PERTHREAD, }; +enum writer_state { + WRITER_STATE_SYNC_RCU, + WRITER_STATE_CALL_RCU, + WRITER_STATE_POLL_RCU, +}; + static enum callrcu_type callrcu_type = CALLRCU_GLOBAL; long long n_reads = 0LL; @@ -128,6 +122,7 @@ volatile int goflag __attribute__((__aligned__(CAA_CACHE_LINE_SIZE))) * Performance test. */ +static void *rcu_read_perf_test(void *arg) { int i; @@ -158,7 +153,8 @@ void *rcu_read_perf_test(void *arg) return (NULL); } -void *rcu_update_perf_test(void *arg) +static +void *rcu_update_perf_test(void *arg __attribute__((unused))) { long long n_updates_local = 0; @@ -189,6 +185,7 @@ void *rcu_update_perf_test(void *arg) return NULL; } +static void perftestinit(void) { init_per_thread(n_reads_pt, 0LL); @@ -196,6 +193,7 @@ void perftestinit(void) uatomic_set(&nthreadsrunning, 0); } +static int perftestrun(int nthreads, int nreaders, int nupdaters) { int t; @@ -229,6 +227,7 @@ int perftestrun(int nthreads, int nreaders, int nupdaters) return 0; } +static int perftest(int nreaders, int cpustride) { int i; @@ -244,6 +243,7 @@ int perftest(int nreaders, int cpustride) return perftestrun(i + 1, nreaders, 1); } +static int rperftest(int nreaders, int cpustride) { int i; @@ -258,6 +258,7 @@ int rperftest(int nreaders, int cpustride) return perftestrun(i, nreaders, 0); } +static int uperftest(int nupdaters, int cpustride) { int i; @@ -283,7 +284,7 @@ struct rcu_stress { int mbtest; }; -struct rcu_stress rcu_stress_array[RCU_STRESS_PIPE_LEN] = { { 0 } }; +struct rcu_stress rcu_stress_array[RCU_STRESS_PIPE_LEN] = { { 0, 0 } }; struct rcu_stress *rcu_stress_current; int rcu_stress_idx = 0; @@ -292,7 +293,8 @@ DEFINE_PER_THREAD(long long [RCU_STRESS_PIPE_LEN + 1], rcu_stress_count); int garbage = 0; -void *rcu_read_stress_test(void *arg) +static +void *rcu_read_stress_test(void *arg __attribute__((unused))) { int i; int itercnt = 0; @@ -334,8 +336,10 @@ void *rcu_read_stress_test(void *arg) static pthread_mutex_t call_rcu_test_mutex = PTHREAD_MUTEX_INITIALIZER; static pthread_cond_t call_rcu_test_cond = PTHREAD_COND_INITIALIZER; +static bool call_rcu_wait; -void rcu_update_stress_test_rcu(struct rcu_head *head) +static +void rcu_update_stress_test_rcu(struct rcu_head *head __attribute__((unused))) { int ret; @@ -353,6 +357,7 @@ void rcu_update_stress_test_rcu(struct rcu_head *head) strerror(errno)); abort(); } + call_rcu_wait = false; ret = pthread_mutex_unlock(&call_rcu_test_mutex); if (ret) { errno = ret; @@ -362,14 +367,38 @@ void rcu_update_stress_test_rcu(struct rcu_head *head) } } -void *rcu_update_stress_test(void *arg) +static +void advance_writer_state(enum writer_state *state) +{ + switch (*state) { + case WRITER_STATE_SYNC_RCU: + *state = WRITER_STATE_CALL_RCU; + break; + case WRITER_STATE_CALL_RCU: + *state = WRITER_STATE_POLL_RCU; + break; + case WRITER_STATE_POLL_RCU: + *state = WRITER_STATE_SYNC_RCU; + break; + } +} + +static +void *rcu_update_stress_test(void *arg __attribute__((unused))) { int i; struct rcu_stress *p; struct rcu_head rh; + enum writer_state writer_state = WRITER_STATE_SYNC_RCU; + + rcu_register_thread(); + /* Offline for poll. */ + put_thread_offline(); while (goflag == GOFLAG_INIT) (void) poll(NULL, 0, 1); + put_thread_online(); + while (goflag == GOFLAG_RUN) { i = rcu_stress_idx + 1; if (i >= RCU_STRESS_PIPE_LEN) @@ -384,9 +413,12 @@ void *rcu_update_stress_test(void *arg) for (i = 0; i < RCU_STRESS_PIPE_LEN; i++) if (i != rcu_stress_idx) rcu_stress_array[i].pipe_count++; - if (n_updates & 0x1) + switch (writer_state) { + case WRITER_STATE_SYNC_RCU: synchronize_rcu(); - else { + break; + case WRITER_STATE_CALL_RCU: + { int ret; ret = pthread_mutex_lock(&call_rcu_test_mutex); @@ -396,9 +428,8 @@ void *rcu_update_stress_test(void *arg) strerror(errno)); abort(); } - rcu_register_thread(); call_rcu(&rh, rcu_update_stress_test_rcu); - rcu_unregister_thread(); + /* * Our MacOS X test machine with the following * config: @@ -413,8 +444,14 @@ void *rcu_update_stress_test(void *arg) * immediately after call_rcu (call_rcu needs * us to be registered RCU readers). */ - ret = pthread_cond_wait(&call_rcu_test_cond, - &call_rcu_test_mutex); + call_rcu_wait = true; + /* Offline for pthread_cond_wait. */ + put_thread_offline(); + do { + ret = pthread_cond_wait(&call_rcu_test_cond, + &call_rcu_test_mutex); + } while (call_rcu_wait); + put_thread_online(); if (ret) { errno = ret; diag("pthread_cond_signal: %s", @@ -428,14 +465,33 @@ void *rcu_update_stress_test(void *arg) strerror(errno)); abort(); } + break; + } + case WRITER_STATE_POLL_RCU: + { + struct urcu_gp_poll_state poll_state; + + poll_state = start_poll_synchronize_rcu(); + + /* Offline for poll. */ + put_thread_offline(); + while (!poll_state_synchronize_rcu(poll_state)) + (void) poll(NULL, 0, 1); /* Wait for 1ms */ + put_thread_online(); + break; + } } n_updates++; + advance_writer_state(&writer_state); } + rcu_unregister_thread(); + return NULL; } -void *rcu_fake_update_stress_test(void *arg) +static +void *rcu_fake_update_stress_test(void *arg __attribute__((unused))) { if (callrcu_type == CALLRCU_PERTHREAD) { struct call_rcu_data *crdp; @@ -462,6 +518,7 @@ void *rcu_fake_update_stress_test(void *arg) return NULL; } +static int stresstest(int nreaders) { int i; @@ -519,7 +576,11 @@ int stresstest(int nreaders) * Mainprogram. */ -void usage(int argc, char *argv[]) +static +void usage(char *argv[]) __attribute__((__noreturn__)); + +static +void usage(char *argv[]) { diag("Usage: %s nreaders [ perf | rperf | uperf | stress ] [ stride ] [ callrcu_global | callrcu_percpu | callrcu_perthread ]\n", argv[0]); exit(-1); @@ -544,7 +605,7 @@ int main(int argc, char *argv[]) } else if (strcmp(callrcu_str, "callrcu_perthread") == 0) { callrcu_type = CALLRCU_PERTHREAD; } else { - usage(argc, argv); + usage(argv); goto end; } } @@ -574,7 +635,7 @@ int main(int argc, char *argv[]) if (argc > 1) { if (strcmp(argv[1], "-h") == 0 || strcmp(argv[1], "--help") == 0) { - usage(argc, argv); + usage(argv); goto end; } nreaders = strtoul(argv[1], NULL, 0); @@ -603,9 +664,9 @@ int main(int argc, char *argv[]) "stresstest readers: %d, stride: %d", nreaders, cpustride); else - usage(argc, argv); + usage(argv); } else { - usage(argc, argv); + usage(argv); } end: return exit_status();