From 153b081a9b007aad7bece415dc3bf1125edd2da3 Mon Sep 17 00:00:00 2001 From: Simon Marchi Date: Tue, 31 Aug 2021 18:12:44 -0400 Subject: [PATCH] Build and run regression and unit tests as C++ programs Build and run all tests under tests/regression and tests/unit as C++ programs in addition to C. This helps get confidence that urcu, when used from a C++ program, behaves well. Change-Id: Iacaa42dddbcbf59eff8e327edfd0352cce0b74b7 Signed-off-by: Simon Marchi Signed-off-by: Mathieu Desnoyers --- .gitignore | 18 +- configure.ac | 75 ++ m4/ax_cxx_compile_stdcxx.m4 | 962 ++++++++++++++++++ tests/common/api.h | 2 +- tests/regression/Makefile.am | 100 +- tests/regression/rcutorture.h | 2 +- .../rcutorture_urcu_bp_perf_global_cxx.tap.in | 1 + .../rcutorture_urcu_bp_perf_percpu_cxx.tap.in | 1 + ...utorture_urcu_bp_perf_perthread_cxx.tap.in | 1 + ...rcutorture_urcu_bp_rperf_global_cxx.tap.in | 1 + ...rcutorture_urcu_bp_rperf_percpu_cxx.tap.in | 1 + ...torture_urcu_bp_rperf_perthread_cxx.tap.in | 1 + ...cutorture_urcu_bp_stress_global_cxx.tap.in | 1 + ...cutorture_urcu_bp_stress_percpu_cxx.tap.in | 1 + ...orture_urcu_bp_stress_perthread_cxx.tap.in | 1 + ...rcutorture_urcu_bp_uperf_global_cxx.tap.in | 1 + ...rcutorture_urcu_bp_uperf_percpu_cxx.tap.in | 1 + ...torture_urcu_bp_uperf_perthread_cxx.tap.in | 1 + .../rcutorture_urcu_mb_perf_global_cxx.tap.in | 1 + .../rcutorture_urcu_mb_perf_percpu_cxx.tap.in | 1 + ...utorture_urcu_mb_perf_perthread_cxx.tap.in | 1 + ...rcutorture_urcu_mb_rperf_global_cxx.tap.in | 1 + ...rcutorture_urcu_mb_rperf_percpu_cxx.tap.in | 1 + ...torture_urcu_mb_rperf_perthread_cxx.tap.in | 1 + ...cutorture_urcu_mb_stress_global_cxx.tap.in | 1 + ...cutorture_urcu_mb_stress_percpu_cxx.tap.in | 1 + ...orture_urcu_mb_stress_perthread_cxx.tap.in | 1 + ...rcutorture_urcu_mb_uperf_global_cxx.tap.in | 1 + ...rcutorture_urcu_mb_uperf_percpu_cxx.tap.in | 1 + ...torture_urcu_mb_uperf_perthread_cxx.tap.in | 1 + ...ure_urcu_membarrier_perf_global_cxx.tap.in | 1 + ...ure_urcu_membarrier_perf_percpu_cxx.tap.in | 1 + ..._urcu_membarrier_perf_perthread_cxx.tap.in | 1 + ...re_urcu_membarrier_rperf_global_cxx.tap.in | 1 + ...re_urcu_membarrier_rperf_percpu_cxx.tap.in | 1 + ...urcu_membarrier_rperf_perthread_cxx.tap.in | 1 + ...e_urcu_membarrier_stress_global_cxx.tap.in | 1 + ...e_urcu_membarrier_stress_percpu_cxx.tap.in | 1 + ...rcu_membarrier_stress_perthread_cxx.tap.in | 1 + ...re_urcu_membarrier_uperf_global_cxx.tap.in | 1 + ...re_urcu_membarrier_uperf_percpu_cxx.tap.in | 1 + ...urcu_membarrier_uperf_perthread_cxx.tap.in | 1 + ...cutorture_urcu_qsbr_perf_global_cxx.tap.in | 1 + ...cutorture_urcu_qsbr_perf_percpu_cxx.tap.in | 1 + ...orture_urcu_qsbr_perf_perthread_cxx.tap.in | 1 + ...utorture_urcu_qsbr_rperf_global_cxx.tap.in | 1 + ...utorture_urcu_qsbr_rperf_percpu_cxx.tap.in | 1 + ...rture_urcu_qsbr_rperf_perthread_cxx.tap.in | 1 + ...torture_urcu_qsbr_stress_global_cxx.tap.in | 1 + ...torture_urcu_qsbr_stress_percpu_cxx.tap.in | 1 + ...ture_urcu_qsbr_stress_perthread_cxx.tap.in | 1 + ...utorture_urcu_qsbr_uperf_global_cxx.tap.in | 1 + ...utorture_urcu_qsbr_uperf_percpu_cxx.tap.in | 1 + ...rture_urcu_qsbr_uperf_perthread_cxx.tap.in | 1 + ...torture_urcu_signal_perf_global_cxx.tap.in | 1 + ...torture_urcu_signal_perf_percpu_cxx.tap.in | 1 + ...ture_urcu_signal_perf_perthread_cxx.tap.in | 1 + ...orture_urcu_signal_rperf_global_cxx.tap.in | 1 + ...orture_urcu_signal_rperf_percpu_cxx.tap.in | 1 + ...ure_urcu_signal_rperf_perthread_cxx.tap.in | 1 + ...rture_urcu_signal_stress_global_cxx.tap.in | 1 + ...rture_urcu_signal_stress_percpu_cxx.tap.in | 1 + ...re_urcu_signal_stress_perthread_cxx.tap.in | 1 + ...orture_urcu_signal_uperf_global_cxx.tap.in | 1 + ...orture_urcu_signal_uperf_percpu_cxx.tap.in | 1 + ...ure_urcu_signal_uperf_perthread_cxx.tap.in | 1 + tests/regression/test_urcu_fork.c | 2 +- tests/regression/test_urcu_fork_cxx.cpp | 3 + tests/regression/urcutorture_cxx.cpp | 3 + tests/unit/Makefile.am | 42 +- tests/unit/test_arch_cxx.cpp | 3 + tests/unit/test_uatomic_cxx.cpp | 3 + tests/unit/test_urcu_multiflavor-bp_cxx.cpp | 3 + tests/unit/test_urcu_multiflavor-mb_cxx.cpp | 3 + tests/unit/test_urcu_multiflavor-memb_cxx.cpp | 3 + tests/unit/test_urcu_multiflavor-qsbr_cxx.cpp | 3 + .../unit/test_urcu_multiflavor-signal_cxx.cpp | 3 + tests/unit/test_urcu_multiflavor_cxx.cpp | 3 + .../test_urcu_multiflavor_single_unit_cxx.cpp | 3 + tests/unit/urcu-asm_cxx.cpp | 3 + tests/utils/tap.h | 8 + 81 files changed, 1298 insertions(+), 9 deletions(-) create mode 100644 m4/ax_cxx_compile_stdcxx.m4 create mode 100644 tests/regression/rcutorture_urcu_bp_perf_global_cxx.tap.in create mode 100644 tests/regression/rcutorture_urcu_bp_perf_percpu_cxx.tap.in create mode 100644 tests/regression/rcutorture_urcu_bp_perf_perthread_cxx.tap.in create mode 100644 tests/regression/rcutorture_urcu_bp_rperf_global_cxx.tap.in create mode 100644 tests/regression/rcutorture_urcu_bp_rperf_percpu_cxx.tap.in create mode 100644 tests/regression/rcutorture_urcu_bp_rperf_perthread_cxx.tap.in create mode 100644 tests/regression/rcutorture_urcu_bp_stress_global_cxx.tap.in create mode 100644 tests/regression/rcutorture_urcu_bp_stress_percpu_cxx.tap.in create mode 100644 tests/regression/rcutorture_urcu_bp_stress_perthread_cxx.tap.in create mode 100644 tests/regression/rcutorture_urcu_bp_uperf_global_cxx.tap.in create mode 100644 tests/regression/rcutorture_urcu_bp_uperf_percpu_cxx.tap.in create mode 100644 tests/regression/rcutorture_urcu_bp_uperf_perthread_cxx.tap.in create mode 100644 tests/regression/rcutorture_urcu_mb_perf_global_cxx.tap.in create mode 100644 tests/regression/rcutorture_urcu_mb_perf_percpu_cxx.tap.in create mode 100644 tests/regression/rcutorture_urcu_mb_perf_perthread_cxx.tap.in create mode 100644 tests/regression/rcutorture_urcu_mb_rperf_global_cxx.tap.in create mode 100644 tests/regression/rcutorture_urcu_mb_rperf_percpu_cxx.tap.in create mode 100644 tests/regression/rcutorture_urcu_mb_rperf_perthread_cxx.tap.in create mode 100644 tests/regression/rcutorture_urcu_mb_stress_global_cxx.tap.in create mode 100644 tests/regression/rcutorture_urcu_mb_stress_percpu_cxx.tap.in create mode 100644 tests/regression/rcutorture_urcu_mb_stress_perthread_cxx.tap.in create mode 100644 tests/regression/rcutorture_urcu_mb_uperf_global_cxx.tap.in create mode 100644 tests/regression/rcutorture_urcu_mb_uperf_percpu_cxx.tap.in create mode 100644 tests/regression/rcutorture_urcu_mb_uperf_perthread_cxx.tap.in create mode 100644 tests/regression/rcutorture_urcu_membarrier_perf_global_cxx.tap.in create mode 100644 tests/regression/rcutorture_urcu_membarrier_perf_percpu_cxx.tap.in create mode 100644 tests/regression/rcutorture_urcu_membarrier_perf_perthread_cxx.tap.in create mode 100644 tests/regression/rcutorture_urcu_membarrier_rperf_global_cxx.tap.in create mode 100644 tests/regression/rcutorture_urcu_membarrier_rperf_percpu_cxx.tap.in create mode 100644 tests/regression/rcutorture_urcu_membarrier_rperf_perthread_cxx.tap.in create mode 100644 tests/regression/rcutorture_urcu_membarrier_stress_global_cxx.tap.in create mode 100644 tests/regression/rcutorture_urcu_membarrier_stress_percpu_cxx.tap.in create mode 100644 tests/regression/rcutorture_urcu_membarrier_stress_perthread_cxx.tap.in create mode 100644 tests/regression/rcutorture_urcu_membarrier_uperf_global_cxx.tap.in create mode 100644 tests/regression/rcutorture_urcu_membarrier_uperf_percpu_cxx.tap.in create mode 100644 tests/regression/rcutorture_urcu_membarrier_uperf_perthread_cxx.tap.in create mode 100644 tests/regression/rcutorture_urcu_qsbr_perf_global_cxx.tap.in create mode 100644 tests/regression/rcutorture_urcu_qsbr_perf_percpu_cxx.tap.in create mode 100644 tests/regression/rcutorture_urcu_qsbr_perf_perthread_cxx.tap.in create mode 100644 tests/regression/rcutorture_urcu_qsbr_rperf_global_cxx.tap.in create mode 100644 tests/regression/rcutorture_urcu_qsbr_rperf_percpu_cxx.tap.in create mode 100644 tests/regression/rcutorture_urcu_qsbr_rperf_perthread_cxx.tap.in create mode 100644 tests/regression/rcutorture_urcu_qsbr_stress_global_cxx.tap.in create mode 100644 tests/regression/rcutorture_urcu_qsbr_stress_percpu_cxx.tap.in create mode 100644 tests/regression/rcutorture_urcu_qsbr_stress_perthread_cxx.tap.in create mode 100644 tests/regression/rcutorture_urcu_qsbr_uperf_global_cxx.tap.in create mode 100644 tests/regression/rcutorture_urcu_qsbr_uperf_percpu_cxx.tap.in create mode 100644 tests/regression/rcutorture_urcu_qsbr_uperf_perthread_cxx.tap.in create mode 100644 tests/regression/rcutorture_urcu_signal_perf_global_cxx.tap.in create mode 100644 tests/regression/rcutorture_urcu_signal_perf_percpu_cxx.tap.in create mode 100644 tests/regression/rcutorture_urcu_signal_perf_perthread_cxx.tap.in create mode 100644 tests/regression/rcutorture_urcu_signal_rperf_global_cxx.tap.in create mode 100644 tests/regression/rcutorture_urcu_signal_rperf_percpu_cxx.tap.in create mode 100644 tests/regression/rcutorture_urcu_signal_rperf_perthread_cxx.tap.in create mode 100644 tests/regression/rcutorture_urcu_signal_stress_global_cxx.tap.in create mode 100644 tests/regression/rcutorture_urcu_signal_stress_percpu_cxx.tap.in create mode 100644 tests/regression/rcutorture_urcu_signal_stress_perthread_cxx.tap.in create mode 100644 tests/regression/rcutorture_urcu_signal_uperf_global_cxx.tap.in create mode 100644 tests/regression/rcutorture_urcu_signal_uperf_percpu_cxx.tap.in create mode 100644 tests/regression/rcutorture_urcu_signal_uperf_perthread_cxx.tap.in create mode 100644 tests/regression/test_urcu_fork_cxx.cpp create mode 100644 tests/regression/urcutorture_cxx.cpp create mode 100644 tests/unit/test_arch_cxx.cpp create mode 100644 tests/unit/test_uatomic_cxx.cpp create mode 100644 tests/unit/test_urcu_multiflavor-bp_cxx.cpp create mode 100644 tests/unit/test_urcu_multiflavor-mb_cxx.cpp create mode 100644 tests/unit/test_urcu_multiflavor-memb_cxx.cpp create mode 100644 tests/unit/test_urcu_multiflavor-qsbr_cxx.cpp create mode 100644 tests/unit/test_urcu_multiflavor-signal_cxx.cpp create mode 100644 tests/unit/test_urcu_multiflavor_cxx.cpp create mode 100644 tests/unit/test_urcu_multiflavor_single_unit_cxx.cpp create mode 100644 tests/unit/urcu-asm_cxx.cpp diff --git a/.gitignore b/.gitignore index a028211..23c2769 100644 --- a/.gitignore +++ b/.gitignore @@ -3,19 +3,35 @@ tests/api.h tests/unit/urcu-asm.S tests/unit/test_arch +tests/unit/test_arch_cxx +tests/unit/test_build +tests/unit/test_build_cxx +tests/unit/test_build_dynlink +tests/unit/test_build_dynlink_cxx tests/unit/test_uatomic +tests/unit/test_uatomic_cxx tests/unit/test_urcu_multiflavor +tests/unit/test_urcu_multiflavor_cxx tests/unit/test_urcu_multiflavor_dynlink +tests/unit/test_urcu_multiflavor_dynlink_cxx tests/unit/test_urcu_multiflavor_single_unit +tests/unit/test_urcu_multiflavor_single_unit_cxx tests/unit/test_urcu_multiflavor_single_unit_dynlink +tests/unit/test_urcu_multiflavor_single_unit_dynlink_cxx tests/utils/libtap.a -tests/regression/rcutorture_urcu_membarrier tests/regression/rcutorture_urcu_bp +tests/regression/rcutorture_urcu_bp_cxx tests/regression/rcutorture_urcu_mb +tests/regression/rcutorture_urcu_mb_cxx +tests/regression/rcutorture_urcu_membarrier +tests/regression/rcutorture_urcu_membarrier_cxx tests/regression/rcutorture_urcu_qsbr +tests/regression/rcutorture_urcu_qsbr_cxx tests/regression/rcutorture_urcu_signal +tests/regression/rcutorture_urcu_signal_cxx +tests/regression/test_urcu_fork_cxx.tap tests/regression/test_urcu_fork.tap tests/regression/rcutorture*.tap diff --git a/configure.ac b/configure.ac index 4ffe868..1ebdbc4 100644 --- a/configure.ac +++ b/configure.ac @@ -71,6 +71,13 @@ AS_IF([test "$ac_cv_prog_cc_c99" = "no"], [AC_MSG_ERROR([The compiler does not s AC_USE_SYSTEM_EXTENSIONS AC_SYS_LARGEFILE +## ## +## C++ compiler checks ## +## ## + +# Require a C++11 compiler without GNU extensions (-std=c++11) +AX_CXX_COMPILE_STDCXX([11], [noext], [mandatory]) + # Make sure the C compiler supports __attribute__ AX_C___ATTRIBUTE__ AS_IF([test "x$ax_cv___attribute__" != "xyes"], @@ -124,7 +131,12 @@ AC_LANG_PUSH([C]) AX_APPEND_COMPILE_FLAGS([WARN_FLAGS_LIST], [WARN_CFLAGS], [-Werror]) AC_LANG_POP([C]) +AC_LANG_PUSH([C++]) +AX_APPEND_COMPILE_FLAGS([WARN_FLAGS_LIST], [WARN_CXXFLAGS], [-Werror]) +AC_LANG_POP([C++]) + AE_IF_FEATURE_ENABLED([Werror], [WARN_CFLAGS="${WARN_CFLAGS} -Werror"]) +AE_IF_FEATURE_ENABLED([Werror], [WARN_CXXFLAGS="${WARN_CXXFLAGS} -Werror"]) ## ## @@ -281,6 +293,9 @@ AC_SUBST(AM_CPPFLAGS) AM_CFLAGS="$WARN_CFLAGS $PTHREAD_CFLAGS" AC_SUBST(AM_CFLAGS) +AM_CXXFLAGS="$WARN_CXXFLAGS $PTHREAD_CFLAGS" +AC_SUBST(AM_CXXFLAGS) + ## ## ## Output files generated by configure ## @@ -308,65 +323,125 @@ AC_CONFIG_FILES([ ]) AC_CONFIG_FILES([tests/regression/rcutorture_urcu_bp_perf_global.tap], [chmod +x tests/regression/rcutorture_urcu_bp_perf_global.tap]) +AC_CONFIG_FILES([tests/regression/rcutorture_urcu_bp_perf_global_cxx.tap], [chmod +x tests/regression/rcutorture_urcu_bp_perf_global_cxx.tap]) AC_CONFIG_FILES([tests/regression/rcutorture_urcu_bp_perf_percpu.tap], [chmod +x tests/regression/rcutorture_urcu_bp_perf_percpu.tap]) +AC_CONFIG_FILES([tests/regression/rcutorture_urcu_bp_perf_percpu_cxx.tap], [chmod +x tests/regression/rcutorture_urcu_bp_perf_percpu_cxx.tap]) AC_CONFIG_FILES([tests/regression/rcutorture_urcu_bp_perf_perthread.tap], [chmod +x tests/regression/rcutorture_urcu_bp_perf_perthread.tap]) +AC_CONFIG_FILES([tests/regression/rcutorture_urcu_bp_perf_perthread_cxx.tap], [chmod +x tests/regression/rcutorture_urcu_bp_perf_perthread_cxx.tap]) AC_CONFIG_FILES([tests/regression/rcutorture_urcu_bp_rperf_global.tap], [chmod +x tests/regression/rcutorture_urcu_bp_rperf_global.tap]) +AC_CONFIG_FILES([tests/regression/rcutorture_urcu_bp_rperf_global_cxx.tap], [chmod +x tests/regression/rcutorture_urcu_bp_rperf_global_cxx.tap]) AC_CONFIG_FILES([tests/regression/rcutorture_urcu_bp_rperf_percpu.tap], [chmod +x tests/regression/rcutorture_urcu_bp_rperf_percpu.tap]) +AC_CONFIG_FILES([tests/regression/rcutorture_urcu_bp_rperf_percpu_cxx.tap], [chmod +x tests/regression/rcutorture_urcu_bp_rperf_percpu_cxx.tap]) AC_CONFIG_FILES([tests/regression/rcutorture_urcu_bp_rperf_perthread.tap], [chmod +x tests/regression/rcutorture_urcu_bp_rperf_perthread.tap]) +AC_CONFIG_FILES([tests/regression/rcutorture_urcu_bp_rperf_perthread_cxx.tap], [chmod +x tests/regression/rcutorture_urcu_bp_rperf_perthread_cxx.tap]) AC_CONFIG_FILES([tests/regression/rcutorture_urcu_bp_stress_global.tap], [chmod +x tests/regression/rcutorture_urcu_bp_stress_global.tap]) +AC_CONFIG_FILES([tests/regression/rcutorture_urcu_bp_stress_global_cxx.tap], [chmod +x tests/regression/rcutorture_urcu_bp_stress_global_cxx.tap]) AC_CONFIG_FILES([tests/regression/rcutorture_urcu_bp_stress_percpu.tap], [chmod +x tests/regression/rcutorture_urcu_bp_stress_percpu.tap]) +AC_CONFIG_FILES([tests/regression/rcutorture_urcu_bp_stress_percpu_cxx.tap], [chmod +x tests/regression/rcutorture_urcu_bp_stress_percpu_cxx.tap]) AC_CONFIG_FILES([tests/regression/rcutorture_urcu_bp_stress_perthread.tap], [chmod +x tests/regression/rcutorture_urcu_bp_stress_perthread.tap]) +AC_CONFIG_FILES([tests/regression/rcutorture_urcu_bp_stress_perthread_cxx.tap], [chmod +x tests/regression/rcutorture_urcu_bp_stress_perthread_cxx.tap]) AC_CONFIG_FILES([tests/regression/rcutorture_urcu_bp_uperf_global.tap], [chmod +x tests/regression/rcutorture_urcu_bp_uperf_global.tap]) +AC_CONFIG_FILES([tests/regression/rcutorture_urcu_bp_uperf_global_cxx.tap], [chmod +x tests/regression/rcutorture_urcu_bp_uperf_global_cxx.tap]) AC_CONFIG_FILES([tests/regression/rcutorture_urcu_bp_uperf_percpu.tap], [chmod +x tests/regression/rcutorture_urcu_bp_uperf_percpu.tap]) +AC_CONFIG_FILES([tests/regression/rcutorture_urcu_bp_uperf_percpu_cxx.tap], [chmod +x tests/regression/rcutorture_urcu_bp_uperf_percpu_cxx.tap]) AC_CONFIG_FILES([tests/regression/rcutorture_urcu_bp_uperf_perthread.tap], [chmod +x tests/regression/rcutorture_urcu_bp_uperf_perthread.tap]) +AC_CONFIG_FILES([tests/regression/rcutorture_urcu_bp_uperf_perthread_cxx.tap], [chmod +x tests/regression/rcutorture_urcu_bp_uperf_perthread_cxx.tap]) AC_CONFIG_FILES([tests/regression/rcutorture_urcu_mb_perf_global.tap], [chmod +x tests/regression/rcutorture_urcu_mb_perf_global.tap]) +AC_CONFIG_FILES([tests/regression/rcutorture_urcu_mb_perf_global_cxx.tap], [chmod +x tests/regression/rcutorture_urcu_mb_perf_global_cxx.tap]) AC_CONFIG_FILES([tests/regression/rcutorture_urcu_mb_perf_percpu.tap], [chmod +x tests/regression/rcutorture_urcu_mb_perf_percpu.tap]) +AC_CONFIG_FILES([tests/regression/rcutorture_urcu_mb_perf_percpu_cxx.tap], [chmod +x tests/regression/rcutorture_urcu_mb_perf_percpu_cxx.tap]) AC_CONFIG_FILES([tests/regression/rcutorture_urcu_mb_perf_perthread.tap], [chmod +x tests/regression/rcutorture_urcu_mb_perf_perthread.tap]) +AC_CONFIG_FILES([tests/regression/rcutorture_urcu_mb_perf_perthread_cxx.tap], [chmod +x tests/regression/rcutorture_urcu_mb_perf_perthread_cxx.tap]) AC_CONFIG_FILES([tests/regression/rcutorture_urcu_mb_rperf_global.tap], [chmod +x tests/regression/rcutorture_urcu_mb_rperf_global.tap]) +AC_CONFIG_FILES([tests/regression/rcutorture_urcu_mb_rperf_global_cxx.tap], [chmod +x tests/regression/rcutorture_urcu_mb_rperf_global_cxx.tap]) AC_CONFIG_FILES([tests/regression/rcutorture_urcu_mb_rperf_percpu.tap], [chmod +x tests/regression/rcutorture_urcu_mb_rperf_percpu.tap]) +AC_CONFIG_FILES([tests/regression/rcutorture_urcu_mb_rperf_percpu_cxx.tap], [chmod +x tests/regression/rcutorture_urcu_mb_rperf_percpu_cxx.tap]) AC_CONFIG_FILES([tests/regression/rcutorture_urcu_mb_rperf_perthread.tap], [chmod +x tests/regression/rcutorture_urcu_mb_rperf_perthread.tap]) +AC_CONFIG_FILES([tests/regression/rcutorture_urcu_mb_rperf_perthread_cxx.tap], [chmod +x tests/regression/rcutorture_urcu_mb_rperf_perthread_cxx.tap]) AC_CONFIG_FILES([tests/regression/rcutorture_urcu_mb_stress_global.tap], [chmod +x tests/regression/rcutorture_urcu_mb_stress_global.tap]) +AC_CONFIG_FILES([tests/regression/rcutorture_urcu_mb_stress_global_cxx.tap], [chmod +x tests/regression/rcutorture_urcu_mb_stress_global_cxx.tap]) AC_CONFIG_FILES([tests/regression/rcutorture_urcu_mb_stress_percpu.tap], [chmod +x tests/regression/rcutorture_urcu_mb_stress_percpu.tap]) +AC_CONFIG_FILES([tests/regression/rcutorture_urcu_mb_stress_percpu_cxx.tap], [chmod +x tests/regression/rcutorture_urcu_mb_stress_percpu_cxx.tap]) AC_CONFIG_FILES([tests/regression/rcutorture_urcu_mb_stress_perthread.tap], [chmod +x tests/regression/rcutorture_urcu_mb_stress_perthread.tap]) +AC_CONFIG_FILES([tests/regression/rcutorture_urcu_mb_stress_perthread_cxx.tap], [chmod +x tests/regression/rcutorture_urcu_mb_stress_perthread_cxx.tap]) AC_CONFIG_FILES([tests/regression/rcutorture_urcu_mb_uperf_global.tap], [chmod +x tests/regression/rcutorture_urcu_mb_uperf_global.tap]) +AC_CONFIG_FILES([tests/regression/rcutorture_urcu_mb_uperf_global_cxx.tap], [chmod +x tests/regression/rcutorture_urcu_mb_uperf_global_cxx.tap]) AC_CONFIG_FILES([tests/regression/rcutorture_urcu_mb_uperf_percpu.tap], [chmod +x tests/regression/rcutorture_urcu_mb_uperf_percpu.tap]) +AC_CONFIG_FILES([tests/regression/rcutorture_urcu_mb_uperf_percpu_cxx.tap], [chmod +x tests/regression/rcutorture_urcu_mb_uperf_percpu_cxx.tap]) AC_CONFIG_FILES([tests/regression/rcutorture_urcu_mb_uperf_perthread.tap], [chmod +x tests/regression/rcutorture_urcu_mb_uperf_perthread.tap]) +AC_CONFIG_FILES([tests/regression/rcutorture_urcu_mb_uperf_perthread_cxx.tap], [chmod +x tests/regression/rcutorture_urcu_mb_uperf_perthread_cxx.tap]) AC_CONFIG_FILES([tests/regression/rcutorture_urcu_membarrier_perf_global.tap], [chmod +x tests/regression/rcutorture_urcu_membarrier_perf_global.tap]) +AC_CONFIG_FILES([tests/regression/rcutorture_urcu_membarrier_perf_global_cxx.tap], [chmod +x tests/regression/rcutorture_urcu_membarrier_perf_global_cxx.tap]) AC_CONFIG_FILES([tests/regression/rcutorture_urcu_membarrier_perf_percpu.tap], [chmod +x tests/regression/rcutorture_urcu_membarrier_perf_percpu.tap]) +AC_CONFIG_FILES([tests/regression/rcutorture_urcu_membarrier_perf_percpu_cxx.tap], [chmod +x tests/regression/rcutorture_urcu_membarrier_perf_percpu_cxx.tap]) AC_CONFIG_FILES([tests/regression/rcutorture_urcu_membarrier_perf_perthread.tap], [chmod +x tests/regression/rcutorture_urcu_membarrier_perf_perthread.tap]) +AC_CONFIG_FILES([tests/regression/rcutorture_urcu_membarrier_perf_perthread_cxx.tap], [chmod +x tests/regression/rcutorture_urcu_membarrier_perf_perthread_cxx.tap]) AC_CONFIG_FILES([tests/regression/rcutorture_urcu_membarrier_rperf_global.tap], [chmod +x tests/regression/rcutorture_urcu_membarrier_rperf_global.tap]) +AC_CONFIG_FILES([tests/regression/rcutorture_urcu_membarrier_rperf_global_cxx.tap], [chmod +x tests/regression/rcutorture_urcu_membarrier_rperf_global_cxx.tap]) AC_CONFIG_FILES([tests/regression/rcutorture_urcu_membarrier_rperf_percpu.tap], [chmod +x tests/regression/rcutorture_urcu_membarrier_rperf_percpu.tap]) +AC_CONFIG_FILES([tests/regression/rcutorture_urcu_membarrier_rperf_percpu_cxx.tap], [chmod +x tests/regression/rcutorture_urcu_membarrier_rperf_percpu_cxx.tap]) AC_CONFIG_FILES([tests/regression/rcutorture_urcu_membarrier_rperf_perthread.tap], [chmod +x tests/regression/rcutorture_urcu_membarrier_rperf_perthread.tap]) +AC_CONFIG_FILES([tests/regression/rcutorture_urcu_membarrier_rperf_perthread_cxx.tap], [chmod +x tests/regression/rcutorture_urcu_membarrier_rperf_perthread_cxx.tap]) AC_CONFIG_FILES([tests/regression/rcutorture_urcu_membarrier_stress_global.tap], [chmod +x tests/regression/rcutorture_urcu_membarrier_stress_global.tap]) +AC_CONFIG_FILES([tests/regression/rcutorture_urcu_membarrier_stress_global_cxx.tap], [chmod +x tests/regression/rcutorture_urcu_membarrier_stress_global_cxx.tap]) AC_CONFIG_FILES([tests/regression/rcutorture_urcu_membarrier_stress_percpu.tap], [chmod +x tests/regression/rcutorture_urcu_membarrier_stress_percpu.tap]) +AC_CONFIG_FILES([tests/regression/rcutorture_urcu_membarrier_stress_percpu_cxx.tap], [chmod +x tests/regression/rcutorture_urcu_membarrier_stress_percpu_cxx.tap]) AC_CONFIG_FILES([tests/regression/rcutorture_urcu_membarrier_stress_perthread.tap], [chmod +x tests/regression/rcutorture_urcu_membarrier_stress_perthread.tap]) +AC_CONFIG_FILES([tests/regression/rcutorture_urcu_membarrier_stress_perthread_cxx.tap], [chmod +x tests/regression/rcutorture_urcu_membarrier_stress_perthread_cxx.tap]) AC_CONFIG_FILES([tests/regression/rcutorture_urcu_membarrier_uperf_global.tap], [chmod +x tests/regression/rcutorture_urcu_membarrier_uperf_global.tap]) +AC_CONFIG_FILES([tests/regression/rcutorture_urcu_membarrier_uperf_global_cxx.tap], [chmod +x tests/regression/rcutorture_urcu_membarrier_uperf_global_cxx.tap]) AC_CONFIG_FILES([tests/regression/rcutorture_urcu_membarrier_uperf_percpu.tap], [chmod +x tests/regression/rcutorture_urcu_membarrier_uperf_percpu.tap]) +AC_CONFIG_FILES([tests/regression/rcutorture_urcu_membarrier_uperf_percpu_cxx.tap], [chmod +x tests/regression/rcutorture_urcu_membarrier_uperf_percpu_cxx.tap]) AC_CONFIG_FILES([tests/regression/rcutorture_urcu_membarrier_uperf_perthread.tap], [chmod +x tests/regression/rcutorture_urcu_membarrier_uperf_perthread.tap]) +AC_CONFIG_FILES([tests/regression/rcutorture_urcu_membarrier_uperf_perthread_cxx.tap], [chmod +x tests/regression/rcutorture_urcu_membarrier_uperf_perthread_cxx.tap]) AC_CONFIG_FILES([tests/regression/rcutorture_urcu_qsbr_perf_global.tap], [chmod +x tests/regression/rcutorture_urcu_qsbr_perf_global.tap]) +AC_CONFIG_FILES([tests/regression/rcutorture_urcu_qsbr_perf_global_cxx.tap], [chmod +x tests/regression/rcutorture_urcu_qsbr_perf_global_cxx.tap]) AC_CONFIG_FILES([tests/regression/rcutorture_urcu_qsbr_perf_percpu.tap], [chmod +x tests/regression/rcutorture_urcu_qsbr_perf_percpu.tap]) +AC_CONFIG_FILES([tests/regression/rcutorture_urcu_qsbr_perf_percpu_cxx.tap], [chmod +x tests/regression/rcutorture_urcu_qsbr_perf_percpu_cxx.tap]) AC_CONFIG_FILES([tests/regression/rcutorture_urcu_qsbr_perf_perthread.tap], [chmod +x tests/regression/rcutorture_urcu_qsbr_perf_perthread.tap]) +AC_CONFIG_FILES([tests/regression/rcutorture_urcu_qsbr_perf_perthread_cxx.tap], [chmod +x tests/regression/rcutorture_urcu_qsbr_perf_perthread_cxx.tap]) AC_CONFIG_FILES([tests/regression/rcutorture_urcu_qsbr_rperf_global.tap], [chmod +x tests/regression/rcutorture_urcu_qsbr_rperf_global.tap]) +AC_CONFIG_FILES([tests/regression/rcutorture_urcu_qsbr_rperf_global_cxx.tap], [chmod +x tests/regression/rcutorture_urcu_qsbr_rperf_global_cxx.tap]) AC_CONFIG_FILES([tests/regression/rcutorture_urcu_qsbr_rperf_percpu.tap], [chmod +x tests/regression/rcutorture_urcu_qsbr_rperf_percpu.tap]) +AC_CONFIG_FILES([tests/regression/rcutorture_urcu_qsbr_rperf_percpu_cxx.tap], [chmod +x tests/regression/rcutorture_urcu_qsbr_rperf_percpu_cxx.tap]) AC_CONFIG_FILES([tests/regression/rcutorture_urcu_qsbr_rperf_perthread.tap], [chmod +x tests/regression/rcutorture_urcu_qsbr_rperf_perthread.tap]) +AC_CONFIG_FILES([tests/regression/rcutorture_urcu_qsbr_rperf_perthread_cxx.tap], [chmod +x tests/regression/rcutorture_urcu_qsbr_rperf_perthread_cxx.tap]) AC_CONFIG_FILES([tests/regression/rcutorture_urcu_qsbr_stress_global.tap], [chmod +x tests/regression/rcutorture_urcu_qsbr_stress_global.tap]) +AC_CONFIG_FILES([tests/regression/rcutorture_urcu_qsbr_stress_global_cxx.tap], [chmod +x tests/regression/rcutorture_urcu_qsbr_stress_global_cxx.tap]) AC_CONFIG_FILES([tests/regression/rcutorture_urcu_qsbr_stress_percpu.tap], [chmod +x tests/regression/rcutorture_urcu_qsbr_stress_percpu.tap]) +AC_CONFIG_FILES([tests/regression/rcutorture_urcu_qsbr_stress_percpu_cxx.tap], [chmod +x tests/regression/rcutorture_urcu_qsbr_stress_percpu_cxx.tap]) AC_CONFIG_FILES([tests/regression/rcutorture_urcu_qsbr_stress_perthread.tap], [chmod +x tests/regression/rcutorture_urcu_qsbr_stress_perthread.tap]) +AC_CONFIG_FILES([tests/regression/rcutorture_urcu_qsbr_stress_perthread_cxx.tap], [chmod +x tests/regression/rcutorture_urcu_qsbr_stress_perthread_cxx.tap]) AC_CONFIG_FILES([tests/regression/rcutorture_urcu_qsbr_uperf_global.tap], [chmod +x tests/regression/rcutorture_urcu_qsbr_uperf_global.tap]) +AC_CONFIG_FILES([tests/regression/rcutorture_urcu_qsbr_uperf_global_cxx.tap], [chmod +x tests/regression/rcutorture_urcu_qsbr_uperf_global_cxx.tap]) AC_CONFIG_FILES([tests/regression/rcutorture_urcu_qsbr_uperf_percpu.tap], [chmod +x tests/regression/rcutorture_urcu_qsbr_uperf_percpu.tap]) +AC_CONFIG_FILES([tests/regression/rcutorture_urcu_qsbr_uperf_percpu_cxx.tap], [chmod +x tests/regression/rcutorture_urcu_qsbr_uperf_percpu_cxx.tap]) AC_CONFIG_FILES([tests/regression/rcutorture_urcu_qsbr_uperf_perthread.tap], [chmod +x tests/regression/rcutorture_urcu_qsbr_uperf_perthread.tap]) +AC_CONFIG_FILES([tests/regression/rcutorture_urcu_qsbr_uperf_perthread_cxx.tap], [chmod +x tests/regression/rcutorture_urcu_qsbr_uperf_perthread_cxx.tap]) AC_CONFIG_FILES([tests/regression/rcutorture_urcu_signal_perf_global.tap], [chmod +x tests/regression/rcutorture_urcu_signal_perf_global.tap]) +AC_CONFIG_FILES([tests/regression/rcutorture_urcu_signal_perf_global_cxx.tap], [chmod +x tests/regression/rcutorture_urcu_signal_perf_global_cxx.tap]) AC_CONFIG_FILES([tests/regression/rcutorture_urcu_signal_perf_percpu.tap], [chmod +x tests/regression/rcutorture_urcu_signal_perf_percpu.tap]) +AC_CONFIG_FILES([tests/regression/rcutorture_urcu_signal_perf_percpu_cxx.tap], [chmod +x tests/regression/rcutorture_urcu_signal_perf_percpu_cxx.tap]) AC_CONFIG_FILES([tests/regression/rcutorture_urcu_signal_perf_perthread.tap], [chmod +x tests/regression/rcutorture_urcu_signal_perf_perthread.tap]) +AC_CONFIG_FILES([tests/regression/rcutorture_urcu_signal_perf_perthread_cxx.tap], [chmod +x tests/regression/rcutorture_urcu_signal_perf_perthread_cxx.tap]) AC_CONFIG_FILES([tests/regression/rcutorture_urcu_signal_rperf_global.tap], [chmod +x tests/regression/rcutorture_urcu_signal_rperf_global.tap]) +AC_CONFIG_FILES([tests/regression/rcutorture_urcu_signal_rperf_global_cxx.tap], [chmod +x tests/regression/rcutorture_urcu_signal_rperf_global_cxx.tap]) AC_CONFIG_FILES([tests/regression/rcutorture_urcu_signal_rperf_percpu.tap], [chmod +x tests/regression/rcutorture_urcu_signal_rperf_percpu.tap]) +AC_CONFIG_FILES([tests/regression/rcutorture_urcu_signal_rperf_percpu_cxx.tap], [chmod +x tests/regression/rcutorture_urcu_signal_rperf_percpu_cxx.tap]) AC_CONFIG_FILES([tests/regression/rcutorture_urcu_signal_rperf_perthread.tap], [chmod +x tests/regression/rcutorture_urcu_signal_rperf_perthread.tap]) +AC_CONFIG_FILES([tests/regression/rcutorture_urcu_signal_rperf_perthread_cxx.tap], [chmod +x tests/regression/rcutorture_urcu_signal_rperf_perthread_cxx.tap]) AC_CONFIG_FILES([tests/regression/rcutorture_urcu_signal_stress_global.tap], [chmod +x tests/regression/rcutorture_urcu_signal_stress_global.tap]) +AC_CONFIG_FILES([tests/regression/rcutorture_urcu_signal_stress_global_cxx.tap], [chmod +x tests/regression/rcutorture_urcu_signal_stress_global_cxx.tap]) AC_CONFIG_FILES([tests/regression/rcutorture_urcu_signal_stress_percpu.tap], [chmod +x tests/regression/rcutorture_urcu_signal_stress_percpu.tap]) +AC_CONFIG_FILES([tests/regression/rcutorture_urcu_signal_stress_percpu_cxx.tap], [chmod +x tests/regression/rcutorture_urcu_signal_stress_percpu_cxx.tap]) AC_CONFIG_FILES([tests/regression/rcutorture_urcu_signal_stress_perthread.tap], [chmod +x tests/regression/rcutorture_urcu_signal_stress_perthread.tap]) +AC_CONFIG_FILES([tests/regression/rcutorture_urcu_signal_stress_perthread_cxx.tap], [chmod +x tests/regression/rcutorture_urcu_signal_stress_perthread_cxx.tap]) AC_CONFIG_FILES([tests/regression/rcutorture_urcu_signal_uperf_global.tap], [chmod +x tests/regression/rcutorture_urcu_signal_uperf_global.tap]) +AC_CONFIG_FILES([tests/regression/rcutorture_urcu_signal_uperf_global_cxx.tap], [chmod +x tests/regression/rcutorture_urcu_signal_uperf_global_cxx.tap]) AC_CONFIG_FILES([tests/regression/rcutorture_urcu_signal_uperf_percpu.tap], [chmod +x tests/regression/rcutorture_urcu_signal_uperf_percpu.tap]) +AC_CONFIG_FILES([tests/regression/rcutorture_urcu_signal_uperf_percpu_cxx.tap], [chmod +x tests/regression/rcutorture_urcu_signal_uperf_percpu_cxx.tap]) AC_CONFIG_FILES([tests/regression/rcutorture_urcu_signal_uperf_perthread.tap], [chmod +x tests/regression/rcutorture_urcu_signal_uperf_perthread.tap]) +AC_CONFIG_FILES([tests/regression/rcutorture_urcu_signal_uperf_perthread_cxx.tap], [chmod +x tests/regression/rcutorture_urcu_signal_uperf_perthread_cxx.tap]) AC_OUTPUT diff --git a/m4/ax_cxx_compile_stdcxx.m4 b/m4/ax_cxx_compile_stdcxx.m4 new file mode 100644 index 0000000..9413da6 --- /dev/null +++ b/m4/ax_cxx_compile_stdcxx.m4 @@ -0,0 +1,962 @@ +# =========================================================================== +# https://www.gnu.org/software/autoconf-archive/ax_cxx_compile_stdcxx.html +# =========================================================================== +# +# SYNOPSIS +# +# AX_CXX_COMPILE_STDCXX(VERSION, [ext|noext], [mandatory|optional]) +# +# DESCRIPTION +# +# Check for baseline language coverage in the compiler for the specified +# version of the C++ standard. If necessary, add switches to CXX and +# CXXCPP to enable support. VERSION may be '11' (for the C++11 standard) +# or '14' (for the C++14 standard). +# +# The second argument, if specified, indicates whether you insist on an +# extended mode (e.g. -std=gnu++11) or a strict conformance mode (e.g. +# -std=c++11). If neither is specified, you get whatever works, with +# preference for no added switch, and then for an extended mode. +# +# The third argument, if specified 'mandatory' or if left unspecified, +# indicates that baseline support for the specified C++ standard is +# required and that the macro should error out if no mode with that +# support is found. If specified 'optional', then configuration proceeds +# regardless, after defining HAVE_CXX${VERSION} if and only if a +# supporting mode is found. +# +# LICENSE +# +# Copyright (c) 2008 Benjamin Kosnik +# Copyright (c) 2012 Zack Weinberg +# Copyright (c) 2013 Roy Stogner +# Copyright (c) 2014, 2015 Google Inc.; contributed by Alexey Sokolov +# Copyright (c) 2015 Paul Norman +# Copyright (c) 2015 Moritz Klammler +# Copyright (c) 2016, 2018 Krzesimir Nowak +# Copyright (c) 2019 Enji Cooper +# Copyright (c) 2020 Jason Merrill +# +# Copying and distribution of this file, with or without modification, are +# permitted in any medium without royalty provided the copyright notice +# and this notice are preserved. This file is offered as-is, without any +# warranty. + +#serial 12 + +dnl This macro is based on the code from the AX_CXX_COMPILE_STDCXX_11 macro +dnl (serial version number 13). + +AC_DEFUN([AX_CXX_COMPILE_STDCXX], [dnl + m4_if([$1], [11], [ax_cxx_compile_alternatives="11 0x"], + [$1], [14], [ax_cxx_compile_alternatives="14 1y"], + [$1], [17], [ax_cxx_compile_alternatives="17 1z"], + [m4_fatal([invalid first argument `$1' to AX_CXX_COMPILE_STDCXX])])dnl + m4_if([$2], [], [], + [$2], [ext], [], + [$2], [noext], [], + [m4_fatal([invalid second argument `$2' to AX_CXX_COMPILE_STDCXX])])dnl + m4_if([$3], [], [ax_cxx_compile_cxx$1_required=true], + [$3], [mandatory], [ax_cxx_compile_cxx$1_required=true], + [$3], [optional], [ax_cxx_compile_cxx$1_required=false], + [m4_fatal([invalid third argument `$3' to AX_CXX_COMPILE_STDCXX])]) + AC_LANG_PUSH([C++])dnl + ac_success=no + + m4_if([$2], [], [dnl + AC_CACHE_CHECK(whether $CXX supports C++$1 features by default, + ax_cv_cxx_compile_cxx$1, + [AC_COMPILE_IFELSE([AC_LANG_SOURCE([_AX_CXX_COMPILE_STDCXX_testbody_$1])], + [ax_cv_cxx_compile_cxx$1=yes], + [ax_cv_cxx_compile_cxx$1=no])]) + if test x$ax_cv_cxx_compile_cxx$1 = xyes; then + ac_success=yes + fi]) + + m4_if([$2], [noext], [], [dnl + if test x$ac_success = xno; then + for alternative in ${ax_cxx_compile_alternatives}; do + switch="-std=gnu++${alternative}" + cachevar=AS_TR_SH([ax_cv_cxx_compile_cxx$1_$switch]) + AC_CACHE_CHECK(whether $CXX supports C++$1 features with $switch, + $cachevar, + [ac_save_CXX="$CXX" + CXX="$CXX $switch" + AC_COMPILE_IFELSE([AC_LANG_SOURCE([_AX_CXX_COMPILE_STDCXX_testbody_$1])], + [eval $cachevar=yes], + [eval $cachevar=no]) + CXX="$ac_save_CXX"]) + if eval test x\$$cachevar = xyes; then + CXX="$CXX $switch" + if test -n "$CXXCPP" ; then + CXXCPP="$CXXCPP $switch" + fi + ac_success=yes + break + fi + done + fi]) + + m4_if([$2], [ext], [], [dnl + if test x$ac_success = xno; then + dnl HP's aCC needs +std=c++11 according to: + dnl http://h21007.www2.hp.com/portal/download/files/unprot/aCxx/PDF_Release_Notes/769149-001.pdf + dnl Cray's crayCC needs "-h std=c++11" + for alternative in ${ax_cxx_compile_alternatives}; do + for switch in -std=c++${alternative} +std=c++${alternative} "-h std=c++${alternative}"; do + cachevar=AS_TR_SH([ax_cv_cxx_compile_cxx$1_$switch]) + AC_CACHE_CHECK(whether $CXX supports C++$1 features with $switch, + $cachevar, + [ac_save_CXX="$CXX" + CXX="$CXX $switch" + AC_COMPILE_IFELSE([AC_LANG_SOURCE([_AX_CXX_COMPILE_STDCXX_testbody_$1])], + [eval $cachevar=yes], + [eval $cachevar=no]) + CXX="$ac_save_CXX"]) + if eval test x\$$cachevar = xyes; then + CXX="$CXX $switch" + if test -n "$CXXCPP" ; then + CXXCPP="$CXXCPP $switch" + fi + ac_success=yes + break + fi + done + if test x$ac_success = xyes; then + break + fi + done + fi]) + AC_LANG_POP([C++]) + if test x$ax_cxx_compile_cxx$1_required = xtrue; then + if test x$ac_success = xno; then + AC_MSG_ERROR([*** A compiler with support for C++$1 language features is required.]) + fi + fi + if test x$ac_success = xno; then + HAVE_CXX$1=0 + AC_MSG_NOTICE([No compiler with C++$1 support was found]) + else + HAVE_CXX$1=1 + AC_DEFINE(HAVE_CXX$1,1, + [define if the compiler supports basic C++$1 syntax]) + fi + AC_SUBST(HAVE_CXX$1) +]) + + +dnl Test body for checking C++11 support + +m4_define([_AX_CXX_COMPILE_STDCXX_testbody_11], + _AX_CXX_COMPILE_STDCXX_testbody_new_in_11 +) + + +dnl Test body for checking C++14 support + +m4_define([_AX_CXX_COMPILE_STDCXX_testbody_14], + _AX_CXX_COMPILE_STDCXX_testbody_new_in_11 + _AX_CXX_COMPILE_STDCXX_testbody_new_in_14 +) + +m4_define([_AX_CXX_COMPILE_STDCXX_testbody_17], + _AX_CXX_COMPILE_STDCXX_testbody_new_in_11 + _AX_CXX_COMPILE_STDCXX_testbody_new_in_14 + _AX_CXX_COMPILE_STDCXX_testbody_new_in_17 +) + +dnl Tests for new features in C++11 + +m4_define([_AX_CXX_COMPILE_STDCXX_testbody_new_in_11], [[ + +// If the compiler admits that it is not ready for C++11, why torture it? +// Hopefully, this will speed up the test. + +#ifndef __cplusplus + +#error "This is not a C++ compiler" + +#elif __cplusplus < 201103L + +#error "This is not a C++11 compiler" + +#else + +namespace cxx11 +{ + + namespace test_static_assert + { + + template + struct check + { + static_assert(sizeof(int) <= sizeof(T), "not big enough"); + }; + + } + + namespace test_final_override + { + + struct Base + { + virtual ~Base() {} + virtual void f() {} + }; + + struct Derived : public Base + { + virtual ~Derived() override {} + virtual void f() override {} + }; + + } + + namespace test_double_right_angle_brackets + { + + template < typename T > + struct check {}; + + typedef check single_type; + typedef check> double_type; + typedef check>> triple_type; + typedef check>>> quadruple_type; + + } + + namespace test_decltype + { + + int + f() + { + int a = 1; + decltype(a) b = 2; + return a + b; + } + + } + + namespace test_type_deduction + { + + template < typename T1, typename T2 > + struct is_same + { + static const bool value = false; + }; + + template < typename T > + struct is_same + { + static const bool value = true; + }; + + template < typename T1, typename T2 > + auto + add(T1 a1, T2 a2) -> decltype(a1 + a2) + { + return a1 + a2; + } + + int + test(const int c, volatile int v) + { + static_assert(is_same::value == true, ""); + static_assert(is_same::value == false, ""); + static_assert(is_same::value == false, ""); + auto ac = c; + auto av = v; + auto sumi = ac + av + 'x'; + auto sumf = ac + av + 1.0; + static_assert(is_same::value == true, ""); + static_assert(is_same::value == true, ""); + static_assert(is_same::value == true, ""); + static_assert(is_same::value == false, ""); + static_assert(is_same::value == true, ""); + return (sumf > 0.0) ? sumi : add(c, v); + } + + } + + namespace test_noexcept + { + + int f() { return 0; } + int g() noexcept { return 0; } + + static_assert(noexcept(f()) == false, ""); + static_assert(noexcept(g()) == true, ""); + + } + + namespace test_constexpr + { + + template < typename CharT > + unsigned long constexpr + strlen_c_r(const CharT *const s, const unsigned long acc) noexcept + { + return *s ? strlen_c_r(s + 1, acc + 1) : acc; + } + + template < typename CharT > + unsigned long constexpr + strlen_c(const CharT *const s) noexcept + { + return strlen_c_r(s, 0UL); + } + + static_assert(strlen_c("") == 0UL, ""); + static_assert(strlen_c("1") == 1UL, ""); + static_assert(strlen_c("example") == 7UL, ""); + static_assert(strlen_c("another\0example") == 7UL, ""); + + } + + namespace test_rvalue_references + { + + template < int N > + struct answer + { + static constexpr int value = N; + }; + + answer<1> f(int&) { return answer<1>(); } + answer<2> f(const int&) { return answer<2>(); } + answer<3> f(int&&) { return answer<3>(); } + + void + test() + { + int i = 0; + const int c = 0; + static_assert(decltype(f(i))::value == 1, ""); + static_assert(decltype(f(c))::value == 2, ""); + static_assert(decltype(f(0))::value == 3, ""); + } + + } + + namespace test_uniform_initialization + { + + struct test + { + static const int zero {}; + static const int one {1}; + }; + + static_assert(test::zero == 0, ""); + static_assert(test::one == 1, ""); + + } + + namespace test_lambdas + { + + void + test1() + { + auto lambda1 = [](){}; + auto lambda2 = lambda1; + lambda1(); + lambda2(); + } + + int + test2() + { + auto a = [](int i, int j){ return i + j; }(1, 2); + auto b = []() -> int { return '0'; }(); + auto c = [=](){ return a + b; }(); + auto d = [&](){ return c; }(); + auto e = [a, &b](int x) mutable { + const auto identity = [](int y){ return y; }; + for (auto i = 0; i < a; ++i) + a += b--; + return x + identity(a + b); + }(0); + return a + b + c + d + e; + } + + int + test3() + { + const auto nullary = [](){ return 0; }; + const auto unary = [](int x){ return x; }; + using nullary_t = decltype(nullary); + using unary_t = decltype(unary); + const auto higher1st = [](nullary_t f){ return f(); }; + const auto higher2nd = [unary](nullary_t f1){ + return [unary, f1](unary_t f2){ return f2(unary(f1())); }; + }; + return higher1st(nullary) + higher2nd(nullary)(unary); + } + + } + + namespace test_variadic_templates + { + + template + struct sum; + + template + struct sum + { + static constexpr auto value = N0 + sum::value; + }; + + template <> + struct sum<> + { + static constexpr auto value = 0; + }; + + static_assert(sum<>::value == 0, ""); + static_assert(sum<1>::value == 1, ""); + static_assert(sum<23>::value == 23, ""); + static_assert(sum<1, 2>::value == 3, ""); + static_assert(sum<5, 5, 11>::value == 21, ""); + static_assert(sum<2, 3, 5, 7, 11, 13>::value == 41, ""); + + } + + // http://stackoverflow.com/questions/13728184/template-aliases-and-sfinae + // Clang 3.1 fails with headers of libstd++ 4.8.3 when using std::function + // because of this. + namespace test_template_alias_sfinae + { + + struct foo {}; + + template + using member = typename T::member_type; + + template + void func(...) {} + + template + void func(member*) {} + + void test(); + + void test() { func(0); } + + } + +} // namespace cxx11 + +#endif // __cplusplus >= 201103L + +]]) + + +dnl Tests for new features in C++14 + +m4_define([_AX_CXX_COMPILE_STDCXX_testbody_new_in_14], [[ + +// If the compiler admits that it is not ready for C++14, why torture it? +// Hopefully, this will speed up the test. + +#ifndef __cplusplus + +#error "This is not a C++ compiler" + +#elif __cplusplus < 201402L + +#error "This is not a C++14 compiler" + +#else + +namespace cxx14 +{ + + namespace test_polymorphic_lambdas + { + + int + test() + { + const auto lambda = [](auto&&... args){ + const auto istiny = [](auto x){ + return (sizeof(x) == 1UL) ? 1 : 0; + }; + const int aretiny[] = { istiny(args)... }; + return aretiny[0]; + }; + return lambda(1, 1L, 1.0f, '1'); + } + + } + + namespace test_binary_literals + { + + constexpr auto ivii = 0b0000000000101010; + static_assert(ivii == 42, "wrong value"); + + } + + namespace test_generalized_constexpr + { + + template < typename CharT > + constexpr unsigned long + strlen_c(const CharT *const s) noexcept + { + auto length = 0UL; + for (auto p = s; *p; ++p) + ++length; + return length; + } + + static_assert(strlen_c("") == 0UL, ""); + static_assert(strlen_c("x") == 1UL, ""); + static_assert(strlen_c("test") == 4UL, ""); + static_assert(strlen_c("another\0test") == 7UL, ""); + + } + + namespace test_lambda_init_capture + { + + int + test() + { + auto x = 0; + const auto lambda1 = [a = x](int b){ return a + b; }; + const auto lambda2 = [a = lambda1(x)](){ return a; }; + return lambda2(); + } + + } + + namespace test_digit_separators + { + + constexpr auto ten_million = 100'000'000; + static_assert(ten_million == 100000000, ""); + + } + + namespace test_return_type_deduction + { + + auto f(int& x) { return x; } + decltype(auto) g(int& x) { return x; } + + template < typename T1, typename T2 > + struct is_same + { + static constexpr auto value = false; + }; + + template < typename T > + struct is_same + { + static constexpr auto value = true; + }; + + int + test() + { + auto x = 0; + static_assert(is_same::value, ""); + static_assert(is_same::value, ""); + return x; + } + + } + +} // namespace cxx14 + +#endif // __cplusplus >= 201402L + +]]) + + +dnl Tests for new features in C++17 + +m4_define([_AX_CXX_COMPILE_STDCXX_testbody_new_in_17], [[ + +// If the compiler admits that it is not ready for C++17, why torture it? +// Hopefully, this will speed up the test. + +#ifndef __cplusplus + +#error "This is not a C++ compiler" + +#elif __cplusplus < 201703L + +#error "This is not a C++17 compiler" + +#else + +#include +#include +#include + +namespace cxx17 +{ + + namespace test_constexpr_lambdas + { + + constexpr int foo = [](){return 42;}(); + + } + + namespace test::nested_namespace::definitions + { + + } + + namespace test_fold_expression + { + + template + int multiply(Args... args) + { + return (args * ... * 1); + } + + template + bool all(Args... args) + { + return (args && ...); + } + + } + + namespace test_extended_static_assert + { + + static_assert (true); + + } + + namespace test_auto_brace_init_list + { + + auto foo = {5}; + auto bar {5}; + + static_assert(std::is_same, decltype(foo)>::value); + static_assert(std::is_same::value); + } + + namespace test_typename_in_template_template_parameter + { + + template typename X> struct D; + + } + + namespace test_fallthrough_nodiscard_maybe_unused_attributes + { + + int f1() + { + return 42; + } + + [[nodiscard]] int f2() + { + [[maybe_unused]] auto unused = f1(); + + switch (f1()) + { + case 17: + f1(); + [[fallthrough]]; + case 42: + f1(); + } + return f1(); + } + + } + + namespace test_extended_aggregate_initialization + { + + struct base1 + { + int b1, b2 = 42; + }; + + struct base2 + { + base2() { + b3 = 42; + } + int b3; + }; + + struct derived : base1, base2 + { + int d; + }; + + derived d1 {{1, 2}, {}, 4}; // full initialization + derived d2 {{}, {}, 4}; // value-initialized bases + + } + + namespace test_general_range_based_for_loop + { + + struct iter + { + int i; + + int& operator* () + { + return i; + } + + const int& operator* () const + { + return i; + } + + iter& operator++() + { + ++i; + return *this; + } + }; + + struct sentinel + { + int i; + }; + + bool operator== (const iter& i, const sentinel& s) + { + return i.i == s.i; + } + + bool operator!= (const iter& i, const sentinel& s) + { + return !(i == s); + } + + struct range + { + iter begin() const + { + return {0}; + } + + sentinel end() const + { + return {5}; + } + }; + + void f() + { + range r {}; + + for (auto i : r) + { + [[maybe_unused]] auto v = i; + } + } + + } + + namespace test_lambda_capture_asterisk_this_by_value + { + + struct t + { + int i; + int foo() + { + return [*this]() + { + return i; + }(); + } + }; + + } + + namespace test_enum_class_construction + { + + enum class byte : unsigned char + {}; + + byte foo {42}; + + } + + namespace test_constexpr_if + { + + template + int f () + { + if constexpr(cond) + { + return 13; + } + else + { + return 42; + } + } + + } + + namespace test_selection_statement_with_initializer + { + + int f() + { + return 13; + } + + int f2() + { + if (auto i = f(); i > 0) + { + return 3; + } + + switch (auto i = f(); i + 4) + { + case 17: + return 2; + + default: + return 1; + } + } + + } + + namespace test_template_argument_deduction_for_class_templates + { + + template + struct pair + { + pair (T1 p1, T2 p2) + : m1 {p1}, + m2 {p2} + {} + + T1 m1; + T2 m2; + }; + + void f() + { + [[maybe_unused]] auto p = pair{13, 42u}; + } + + } + + namespace test_non_type_auto_template_parameters + { + + template + struct B + {}; + + B<5> b1; + B<'a'> b2; + + } + + namespace test_structured_bindings + { + + int arr[2] = { 1, 2 }; + std::pair pr = { 1, 2 }; + + auto f1() -> int(&)[2] + { + return arr; + } + + auto f2() -> std::pair& + { + return pr; + } + + struct S + { + int x1 : 2; + volatile double y1; + }; + + S f3() + { + return {}; + } + + auto [ x1, y1 ] = f1(); + auto& [ xr1, yr1 ] = f1(); + auto [ x2, y2 ] = f2(); + auto& [ xr2, yr2 ] = f2(); + const auto [ x3, y3 ] = f3(); + + } + + namespace test_exception_spec_type_system + { + + struct Good {}; + struct Bad {}; + + void g1() noexcept; + void g2(); + + template + Bad + f(T*, T*); + + template + Good + f(T1*, T2*); + + static_assert (std::is_same_v); + + } + + namespace test_inline_variables + { + + template void f(T) + {} + + template inline T g(T) + { + return T{}; + } + + template<> inline void f<>(int) + {} + + template<> int g<>(int) + { + return 5; + } + + } + +} // namespace cxx17 + +#endif // __cplusplus < 201703L + +]]) diff --git a/tests/common/api.h b/tests/common/api.h index 4fe6969..a260463 100644 --- a/tests/common/api.h +++ b/tests/common/api.h @@ -165,7 +165,7 @@ static int smp_thread_id(void) id = pthread_getspecific(thread_id_key); if (id == NULL) return __smp_thread_id(); - return (long)(id - 1); + return ((long) id - 1); } static thread_id_t create_thread(void *(*func)(void *), void *arg) diff --git a/tests/regression/Makefile.am b/tests/regression/Makefile.am index f41bd1a..b8d4acf 100644 --- a/tests/regression/Makefile.am +++ b/tests/regression/Makefile.am @@ -5,12 +5,19 @@ TAP_LOG_DRIVER_FLAGS = --merge --comments TAP_LOG_DRIVER = env AM_TAP_AWK='$(AWK)' $(SHELL) \ $(top_srcdir)/tests/utils/tap-driver.sh -noinst_PROGRAMS = test_urcu_fork.tap \ +noinst_PROGRAMS = \ + test_urcu_fork.tap \ + test_urcu_fork_cxx.tap \ rcutorture_urcu_membarrier \ + rcutorture_urcu_membarrier_cxx \ rcutorture_urcu_signal \ + rcutorture_urcu_signal_cxx \ rcutorture_urcu_mb \ + rcutorture_urcu_mb_cxx \ rcutorture_urcu_bp \ - rcutorture_urcu_qsbr + rcutorture_urcu_bp_cxx \ + rcutorture_urcu_qsbr \ + rcutorture_urcu_qsbr_cxx noinst_HEADERS = rcutorture.h @@ -26,26 +33,49 @@ TAP_LIB=$(top_builddir)/tests/utils/libtap.a test_urcu_fork_tap_SOURCES = test_urcu_fork.c test_urcu_fork_tap_LDADD = $(URCU_LIB) $(TAP_LIB) +test_urcu_fork_cxx_tap_SOURCES = test_urcu_fork_cxx.cpp +test_urcu_fork_cxx_tap_LDADD = $(URCU_LIB) $(TAP_LIB) + rcutorture_urcu_membarrier_SOURCES = urcutorture.c rcutorture_urcu_membarrier_CFLAGS = -DRCU_MEMBARRIER $(AM_CFLAGS) rcutorture_urcu_membarrier_LDADD = $(URCU_LIB) $(TAP_LIB) +rcutorture_urcu_membarrier_cxx_SOURCES = urcutorture_cxx.cpp +rcutorture_urcu_membarrier_cxx_CXXFLAGS = -DRCU_MEMBARRIER $(AM_CXXFLAGS) +rcutorture_urcu_membarrier_cxx_LDADD = $(URCU_LIB) $(TAP_LIB) + rcutorture_urcu_mb_SOURCES = urcutorture.c rcutorture_urcu_mb_CFLAGS = -DRCU_MB $(AM_CFLAGS) rcutorture_urcu_mb_LDADD = $(URCU_MB_LIB) $(TAP_LIB) +rcutorture_urcu_mb_cxx_SOURCES = urcutorture_cxx.cpp +rcutorture_urcu_mb_cxx_CXXFLAGS = -DRCU_MB $(AM_CXXFLAGS) +rcutorture_urcu_mb_cxx_LDADD = $(URCU_MB_LIB) $(TAP_LIB) + rcutorture_urcu_qsbr_SOURCES = urcutorture.c rcutorture_urcu_qsbr_CFLAGS = -DTORTURE_QSBR -DRCU_QSBR $(AM_CFLAGS) rcutorture_urcu_qsbr_LDADD = $(URCU_QSBR_LIB) $(TAP_LIB) +rcutorture_urcu_qsbr_cxx_SOURCES = urcutorture_cxx.cpp +rcutorture_urcu_qsbr_cxx_CXXFLAGS = -DTORTURE_QSBR -DRCU_QSBR $(AM_CXXFLAGS) +rcutorture_urcu_qsbr_cxx_LDADD = $(URCU_QSBR_LIB) $(TAP_LIB) + rcutorture_urcu_signal_SOURCES = urcutorture.c rcutorture_urcu_signal_CFLAGS = -DRCU_SIGNAL $(AM_CFLAGS) rcutorture_urcu_signal_LDADD = $(URCU_SIGNAL_LIB) $(TAP_LIB) +rcutorture_urcu_signal_cxx_SOURCES = urcutorture_cxx.cpp +rcutorture_urcu_signal_cxx_CXXFLAGS = -DRCU_SIGNAL $(AM_CXXFLAGS) +rcutorture_urcu_signal_cxx_LDADD = $(URCU_SIGNAL_LIB) $(TAP_LIB) + rcutorture_urcu_bp_SOURCES = urcutorture.c rcutorture_urcu_bp_CFLAGS = -DRCU_BP $(AM_CFLAGS) rcutorture_urcu_bp_LDADD = $(URCU_BP_LIB) $(TAP_LIB) +rcutorture_urcu_bp_cxx_SOURCES = urcutorture_cxx.cpp +rcutorture_urcu_bp_cxx_CXXFLAGS = -DRCU_BP $(AM_CXXFLAGS) +rcutorture_urcu_bp_cxx_LDADD = $(URCU_BP_LIB) $(TAP_LIB) + urcutorture.c: ../common/api.h .PHONY: regtest @@ -54,67 +84,129 @@ urcutorture.c: ../common/api.h # targets like 'regtest' while keeping the default 'check' a noop. TESTS = -REGTEST_TESTS = test_urcu_fork.tap \ +REGTEST_TESTS = \ + test_urcu_fork.tap \ + test_urcu_fork_cxx.tap \ rcutorture_urcu_bp_perf_global.tap \ + rcutorture_urcu_bp_perf_global_cxx.tap \ rcutorture_urcu_bp_perf_percpu.tap \ + rcutorture_urcu_bp_perf_percpu_cxx.tap \ rcutorture_urcu_bp_perf_perthread.tap \ + rcutorture_urcu_bp_perf_perthread_cxx.tap \ rcutorture_urcu_bp_rperf_global.tap \ + rcutorture_urcu_bp_rperf_global_cxx.tap \ rcutorture_urcu_bp_rperf_percpu.tap \ + rcutorture_urcu_bp_rperf_percpu_cxx.tap \ rcutorture_urcu_bp_rperf_perthread.tap \ + rcutorture_urcu_bp_rperf_perthread_cxx.tap \ rcutorture_urcu_bp_stress_global.tap \ + rcutorture_urcu_bp_stress_global_cxx.tap \ rcutorture_urcu_bp_stress_percpu.tap \ + rcutorture_urcu_bp_stress_percpu_cxx.tap \ rcutorture_urcu_bp_stress_perthread.tap \ + rcutorture_urcu_bp_stress_perthread_cxx.tap \ rcutorture_urcu_bp_uperf_global.tap \ + rcutorture_urcu_bp_uperf_global_cxx.tap \ rcutorture_urcu_bp_uperf_percpu.tap \ + rcutorture_urcu_bp_uperf_percpu_cxx.tap \ rcutorture_urcu_bp_uperf_perthread.tap \ + rcutorture_urcu_bp_uperf_perthread_cxx.tap \ rcutorture_urcu_mb_perf_global.tap \ + rcutorture_urcu_mb_perf_global_cxx.tap \ rcutorture_urcu_mb_perf_percpu.tap \ + rcutorture_urcu_mb_perf_percpu_cxx.tap \ rcutorture_urcu_mb_perf_perthread.tap \ + rcutorture_urcu_mb_perf_perthread_cxx.tap \ rcutorture_urcu_mb_rperf_global.tap \ + rcutorture_urcu_mb_rperf_global_cxx.tap \ rcutorture_urcu_mb_rperf_percpu.tap \ + rcutorture_urcu_mb_rperf_percpu_cxx.tap \ rcutorture_urcu_mb_rperf_perthread.tap \ + rcutorture_urcu_mb_rperf_perthread_cxx.tap \ rcutorture_urcu_mb_stress_global.tap \ + rcutorture_urcu_mb_stress_global_cxx.tap \ rcutorture_urcu_mb_stress_percpu.tap \ + rcutorture_urcu_mb_stress_percpu_cxx.tap \ rcutorture_urcu_mb_stress_perthread.tap \ + rcutorture_urcu_mb_stress_perthread_cxx.tap \ rcutorture_urcu_mb_uperf_global.tap \ + rcutorture_urcu_mb_uperf_global_cxx.tap \ rcutorture_urcu_mb_uperf_percpu.tap \ + rcutorture_urcu_mb_uperf_percpu_cxx.tap \ rcutorture_urcu_mb_uperf_perthread.tap \ + rcutorture_urcu_mb_uperf_perthread_cxx.tap \ rcutorture_urcu_membarrier_perf_global.tap \ + rcutorture_urcu_membarrier_perf_global_cxx.tap \ rcutorture_urcu_membarrier_perf_percpu.tap \ + rcutorture_urcu_membarrier_perf_percpu_cxx.tap \ rcutorture_urcu_membarrier_perf_perthread.tap \ + rcutorture_urcu_membarrier_perf_perthread_cxx.tap \ rcutorture_urcu_membarrier_rperf_global.tap \ + rcutorture_urcu_membarrier_rperf_global_cxx.tap \ rcutorture_urcu_membarrier_rperf_percpu.tap \ + rcutorture_urcu_membarrier_rperf_percpu_cxx.tap \ rcutorture_urcu_membarrier_rperf_perthread.tap \ + rcutorture_urcu_membarrier_rperf_perthread_cxx.tap \ rcutorture_urcu_membarrier_stress_global.tap \ + rcutorture_urcu_membarrier_stress_global_cxx.tap \ rcutorture_urcu_membarrier_stress_percpu.tap \ + rcutorture_urcu_membarrier_stress_percpu_cxx.tap \ rcutorture_urcu_membarrier_stress_perthread.tap \ + rcutorture_urcu_membarrier_stress_perthread_cxx.tap \ rcutorture_urcu_membarrier_uperf_global.tap \ + rcutorture_urcu_membarrier_uperf_global_cxx.tap \ rcutorture_urcu_membarrier_uperf_percpu.tap \ + rcutorture_urcu_membarrier_uperf_percpu_cxx.tap \ rcutorture_urcu_membarrier_uperf_perthread.tap \ + rcutorture_urcu_membarrier_uperf_perthread_cxx.tap \ rcutorture_urcu_qsbr_perf_global.tap \ + rcutorture_urcu_qsbr_perf_global_cxx.tap \ rcutorture_urcu_qsbr_perf_percpu.tap \ + rcutorture_urcu_qsbr_perf_percpu_cxx.tap \ rcutorture_urcu_qsbr_perf_perthread.tap \ + rcutorture_urcu_qsbr_perf_perthread_cxx.tap \ rcutorture_urcu_qsbr_rperf_global.tap \ + rcutorture_urcu_qsbr_rperf_global_cxx.tap \ rcutorture_urcu_qsbr_rperf_percpu.tap \ + rcutorture_urcu_qsbr_rperf_percpu_cxx.tap \ rcutorture_urcu_qsbr_rperf_perthread.tap \ + rcutorture_urcu_qsbr_rperf_perthread_cxx.tap \ rcutorture_urcu_qsbr_stress_global.tap \ + rcutorture_urcu_qsbr_stress_global_cxx.tap \ rcutorture_urcu_qsbr_stress_percpu.tap \ + rcutorture_urcu_qsbr_stress_percpu_cxx.tap \ rcutorture_urcu_qsbr_stress_perthread.tap \ + rcutorture_urcu_qsbr_stress_perthread_cxx.tap \ rcutorture_urcu_qsbr_uperf_global.tap \ + rcutorture_urcu_qsbr_uperf_global_cxx.tap \ rcutorture_urcu_qsbr_uperf_percpu.tap \ + rcutorture_urcu_qsbr_uperf_percpu_cxx.tap \ rcutorture_urcu_qsbr_uperf_perthread.tap \ + rcutorture_urcu_qsbr_uperf_perthread_cxx.tap \ rcutorture_urcu_signal_perf_global.tap \ + rcutorture_urcu_signal_perf_global_cxx.tap \ rcutorture_urcu_signal_perf_percpu.tap \ + rcutorture_urcu_signal_perf_percpu_cxx.tap \ rcutorture_urcu_signal_perf_perthread.tap \ + rcutorture_urcu_signal_perf_perthread_cxx.tap \ rcutorture_urcu_signal_rperf_global.tap \ + rcutorture_urcu_signal_rperf_global_cxx.tap \ rcutorture_urcu_signal_rperf_percpu.tap \ + rcutorture_urcu_signal_rperf_percpu_cxx.tap \ rcutorture_urcu_signal_rperf_perthread.tap \ + rcutorture_urcu_signal_rperf_perthread_cxx.tap \ rcutorture_urcu_signal_stress_global.tap \ + rcutorture_urcu_signal_stress_global_cxx.tap \ rcutorture_urcu_signal_stress_percpu.tap \ + rcutorture_urcu_signal_stress_percpu_cxx.tap \ rcutorture_urcu_signal_stress_perthread.tap \ + rcutorture_urcu_signal_stress_perthread_cxx.tap \ rcutorture_urcu_signal_uperf_global.tap \ + rcutorture_urcu_signal_uperf_global_cxx.tap \ rcutorture_urcu_signal_uperf_percpu.tap \ - rcutorture_urcu_signal_uperf_perthread.tap + rcutorture_urcu_signal_uperf_percpu_cxx.tap \ + rcutorture_urcu_signal_uperf_perthread.tap \ + rcutorture_urcu_signal_uperf_perthread_cxx.tap regtest: $(MAKE) $(AM_MAKEFLAGS) check TESTS="$(REGTEST_TESTS)" diff --git a/tests/regression/rcutorture.h b/tests/regression/rcutorture.h index ac5348c..639fcfc 100644 --- a/tests/regression/rcutorture.h +++ b/tests/regression/rcutorture.h @@ -290,7 +290,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; diff --git a/tests/regression/rcutorture_urcu_bp_perf_global_cxx.tap.in b/tests/regression/rcutorture_urcu_bp_perf_global_cxx.tap.in new file mode 100644 index 0000000..434ce48 --- /dev/null +++ b/tests/regression/rcutorture_urcu_bp_perf_global_cxx.tap.in @@ -0,0 +1 @@ +./rcutorture_urcu_bp_cxx `@NPROC_CMD@` perf 1 callrcu_global diff --git a/tests/regression/rcutorture_urcu_bp_perf_percpu_cxx.tap.in b/tests/regression/rcutorture_urcu_bp_perf_percpu_cxx.tap.in new file mode 100644 index 0000000..3670707 --- /dev/null +++ b/tests/regression/rcutorture_urcu_bp_perf_percpu_cxx.tap.in @@ -0,0 +1 @@ +./rcutorture_urcu_bp_cxx `@NPROC_CMD@` perf 1 callrcu_percpu diff --git a/tests/regression/rcutorture_urcu_bp_perf_perthread_cxx.tap.in b/tests/regression/rcutorture_urcu_bp_perf_perthread_cxx.tap.in new file mode 100644 index 0000000..c7a21f6 --- /dev/null +++ b/tests/regression/rcutorture_urcu_bp_perf_perthread_cxx.tap.in @@ -0,0 +1 @@ +./rcutorture_urcu_bp_cxx `@NPROC_CMD@` perf 1 callrcu_perthread diff --git a/tests/regression/rcutorture_urcu_bp_rperf_global_cxx.tap.in b/tests/regression/rcutorture_urcu_bp_rperf_global_cxx.tap.in new file mode 100644 index 0000000..4f89e4d --- /dev/null +++ b/tests/regression/rcutorture_urcu_bp_rperf_global_cxx.tap.in @@ -0,0 +1 @@ +./rcutorture_urcu_bp_cxx `@NPROC_CMD@` rperf 1 callrcu_global diff --git a/tests/regression/rcutorture_urcu_bp_rperf_percpu_cxx.tap.in b/tests/regression/rcutorture_urcu_bp_rperf_percpu_cxx.tap.in new file mode 100644 index 0000000..3196964 --- /dev/null +++ b/tests/regression/rcutorture_urcu_bp_rperf_percpu_cxx.tap.in @@ -0,0 +1 @@ +./rcutorture_urcu_bp_cxx `@NPROC_CMD@` rperf 1 callrcu_percpu diff --git a/tests/regression/rcutorture_urcu_bp_rperf_perthread_cxx.tap.in b/tests/regression/rcutorture_urcu_bp_rperf_perthread_cxx.tap.in new file mode 100644 index 0000000..edc6833 --- /dev/null +++ b/tests/regression/rcutorture_urcu_bp_rperf_perthread_cxx.tap.in @@ -0,0 +1 @@ +./rcutorture_urcu_bp_cxx `@NPROC_CMD@` rperf 1 callrcu_perthread diff --git a/tests/regression/rcutorture_urcu_bp_stress_global_cxx.tap.in b/tests/regression/rcutorture_urcu_bp_stress_global_cxx.tap.in new file mode 100644 index 0000000..f4ed990 --- /dev/null +++ b/tests/regression/rcutorture_urcu_bp_stress_global_cxx.tap.in @@ -0,0 +1 @@ +./rcutorture_urcu_bp_cxx `@NPROC_CMD@` stress 1 callrcu_global diff --git a/tests/regression/rcutorture_urcu_bp_stress_percpu_cxx.tap.in b/tests/regression/rcutorture_urcu_bp_stress_percpu_cxx.tap.in new file mode 100644 index 0000000..cce2059 --- /dev/null +++ b/tests/regression/rcutorture_urcu_bp_stress_percpu_cxx.tap.in @@ -0,0 +1 @@ +./rcutorture_urcu_bp_cxx `@NPROC_CMD@` stress 1 callrcu_percpu diff --git a/tests/regression/rcutorture_urcu_bp_stress_perthread_cxx.tap.in b/tests/regression/rcutorture_urcu_bp_stress_perthread_cxx.tap.in new file mode 100644 index 0000000..c3417ae --- /dev/null +++ b/tests/regression/rcutorture_urcu_bp_stress_perthread_cxx.tap.in @@ -0,0 +1 @@ +./rcutorture_urcu_bp_cxx `@NPROC_CMD@` stress 1 callrcu_perthread diff --git a/tests/regression/rcutorture_urcu_bp_uperf_global_cxx.tap.in b/tests/regression/rcutorture_urcu_bp_uperf_global_cxx.tap.in new file mode 100644 index 0000000..be9f56f --- /dev/null +++ b/tests/regression/rcutorture_urcu_bp_uperf_global_cxx.tap.in @@ -0,0 +1 @@ +./rcutorture_urcu_bp_cxx `@NPROC_CMD@` uperf 1 callrcu_global diff --git a/tests/regression/rcutorture_urcu_bp_uperf_percpu_cxx.tap.in b/tests/regression/rcutorture_urcu_bp_uperf_percpu_cxx.tap.in new file mode 100644 index 0000000..6e5b261 --- /dev/null +++ b/tests/regression/rcutorture_urcu_bp_uperf_percpu_cxx.tap.in @@ -0,0 +1 @@ +./rcutorture_urcu_bp_cxx `@NPROC_CMD@` uperf 1 callrcu_percpu diff --git a/tests/regression/rcutorture_urcu_bp_uperf_perthread_cxx.tap.in b/tests/regression/rcutorture_urcu_bp_uperf_perthread_cxx.tap.in new file mode 100644 index 0000000..0b9b5e6 --- /dev/null +++ b/tests/regression/rcutorture_urcu_bp_uperf_perthread_cxx.tap.in @@ -0,0 +1 @@ +./rcutorture_urcu_bp_cxx `@NPROC_CMD@` uperf 1 callrcu_perthread diff --git a/tests/regression/rcutorture_urcu_mb_perf_global_cxx.tap.in b/tests/regression/rcutorture_urcu_mb_perf_global_cxx.tap.in new file mode 100644 index 0000000..5f0c23f --- /dev/null +++ b/tests/regression/rcutorture_urcu_mb_perf_global_cxx.tap.in @@ -0,0 +1 @@ +./rcutorture_urcu_mb_cxx `@NPROC_CMD@` perf 1 callrcu_global diff --git a/tests/regression/rcutorture_urcu_mb_perf_percpu_cxx.tap.in b/tests/regression/rcutorture_urcu_mb_perf_percpu_cxx.tap.in new file mode 100644 index 0000000..2748401 --- /dev/null +++ b/tests/regression/rcutorture_urcu_mb_perf_percpu_cxx.tap.in @@ -0,0 +1 @@ +./rcutorture_urcu_mb_cxx `@NPROC_CMD@` perf 1 callrcu_percpu diff --git a/tests/regression/rcutorture_urcu_mb_perf_perthread_cxx.tap.in b/tests/regression/rcutorture_urcu_mb_perf_perthread_cxx.tap.in new file mode 100644 index 0000000..2695d39 --- /dev/null +++ b/tests/regression/rcutorture_urcu_mb_perf_perthread_cxx.tap.in @@ -0,0 +1 @@ +./rcutorture_urcu_mb_cxx `@NPROC_CMD@` perf 1 callrcu_perthread diff --git a/tests/regression/rcutorture_urcu_mb_rperf_global_cxx.tap.in b/tests/regression/rcutorture_urcu_mb_rperf_global_cxx.tap.in new file mode 100644 index 0000000..21f6e7f --- /dev/null +++ b/tests/regression/rcutorture_urcu_mb_rperf_global_cxx.tap.in @@ -0,0 +1 @@ +./rcutorture_urcu_mb_cxx `@NPROC_CMD@` rperf 1 callrcu_global diff --git a/tests/regression/rcutorture_urcu_mb_rperf_percpu_cxx.tap.in b/tests/regression/rcutorture_urcu_mb_rperf_percpu_cxx.tap.in new file mode 100644 index 0000000..d5e2f73 --- /dev/null +++ b/tests/regression/rcutorture_urcu_mb_rperf_percpu_cxx.tap.in @@ -0,0 +1 @@ +./rcutorture_urcu_mb_cxx `@NPROC_CMD@` rperf 1 callrcu_percpu diff --git a/tests/regression/rcutorture_urcu_mb_rperf_perthread_cxx.tap.in b/tests/regression/rcutorture_urcu_mb_rperf_perthread_cxx.tap.in new file mode 100644 index 0000000..72c8d22 --- /dev/null +++ b/tests/regression/rcutorture_urcu_mb_rperf_perthread_cxx.tap.in @@ -0,0 +1 @@ +./rcutorture_urcu_mb_cxx `@NPROC_CMD@` rperf 1 callrcu_perthread diff --git a/tests/regression/rcutorture_urcu_mb_stress_global_cxx.tap.in b/tests/regression/rcutorture_urcu_mb_stress_global_cxx.tap.in new file mode 100644 index 0000000..5e089b2 --- /dev/null +++ b/tests/regression/rcutorture_urcu_mb_stress_global_cxx.tap.in @@ -0,0 +1 @@ +./rcutorture_urcu_mb_cxx `@NPROC_CMD@` stress 1 callrcu_global diff --git a/tests/regression/rcutorture_urcu_mb_stress_percpu_cxx.tap.in b/tests/regression/rcutorture_urcu_mb_stress_percpu_cxx.tap.in new file mode 100644 index 0000000..e542526 --- /dev/null +++ b/tests/regression/rcutorture_urcu_mb_stress_percpu_cxx.tap.in @@ -0,0 +1 @@ +./rcutorture_urcu_mb_cxx `@NPROC_CMD@` stress 1 callrcu_percpu diff --git a/tests/regression/rcutorture_urcu_mb_stress_perthread_cxx.tap.in b/tests/regression/rcutorture_urcu_mb_stress_perthread_cxx.tap.in new file mode 100644 index 0000000..083550e --- /dev/null +++ b/tests/regression/rcutorture_urcu_mb_stress_perthread_cxx.tap.in @@ -0,0 +1 @@ +./rcutorture_urcu_mb_cxx `@NPROC_CMD@` stress 1 callrcu_perthread diff --git a/tests/regression/rcutorture_urcu_mb_uperf_global_cxx.tap.in b/tests/regression/rcutorture_urcu_mb_uperf_global_cxx.tap.in new file mode 100644 index 0000000..b4278ab --- /dev/null +++ b/tests/regression/rcutorture_urcu_mb_uperf_global_cxx.tap.in @@ -0,0 +1 @@ +./rcutorture_urcu_mb_cxx `@NPROC_CMD@` uperf 1 callrcu_global diff --git a/tests/regression/rcutorture_urcu_mb_uperf_percpu_cxx.tap.in b/tests/regression/rcutorture_urcu_mb_uperf_percpu_cxx.tap.in new file mode 100644 index 0000000..2b9ba17 --- /dev/null +++ b/tests/regression/rcutorture_urcu_mb_uperf_percpu_cxx.tap.in @@ -0,0 +1 @@ +./rcutorture_urcu_mb_cxx `@NPROC_CMD@` uperf 1 callrcu_percpu diff --git a/tests/regression/rcutorture_urcu_mb_uperf_perthread_cxx.tap.in b/tests/regression/rcutorture_urcu_mb_uperf_perthread_cxx.tap.in new file mode 100644 index 0000000..00c3e53 --- /dev/null +++ b/tests/regression/rcutorture_urcu_mb_uperf_perthread_cxx.tap.in @@ -0,0 +1 @@ +./rcutorture_urcu_mb_cxx `@NPROC_CMD@` uperf 1 callrcu_perthread diff --git a/tests/regression/rcutorture_urcu_membarrier_perf_global_cxx.tap.in b/tests/regression/rcutorture_urcu_membarrier_perf_global_cxx.tap.in new file mode 100644 index 0000000..77396c7 --- /dev/null +++ b/tests/regression/rcutorture_urcu_membarrier_perf_global_cxx.tap.in @@ -0,0 +1 @@ +./rcutorture_urcu_membarrier_cxx `@NPROC_CMD@` perf 1 callrcu_global diff --git a/tests/regression/rcutorture_urcu_membarrier_perf_percpu_cxx.tap.in b/tests/regression/rcutorture_urcu_membarrier_perf_percpu_cxx.tap.in new file mode 100644 index 0000000..1085754 --- /dev/null +++ b/tests/regression/rcutorture_urcu_membarrier_perf_percpu_cxx.tap.in @@ -0,0 +1 @@ +./rcutorture_urcu_membarrier_cxx `@NPROC_CMD@` perf 1 callrcu_percpu diff --git a/tests/regression/rcutorture_urcu_membarrier_perf_perthread_cxx.tap.in b/tests/regression/rcutorture_urcu_membarrier_perf_perthread_cxx.tap.in new file mode 100644 index 0000000..5369d8b --- /dev/null +++ b/tests/regression/rcutorture_urcu_membarrier_perf_perthread_cxx.tap.in @@ -0,0 +1 @@ +./rcutorture_urcu_membarrier_cxx `@NPROC_CMD@` perf 1 callrcu_perthread diff --git a/tests/regression/rcutorture_urcu_membarrier_rperf_global_cxx.tap.in b/tests/regression/rcutorture_urcu_membarrier_rperf_global_cxx.tap.in new file mode 100644 index 0000000..ea2b3dc --- /dev/null +++ b/tests/regression/rcutorture_urcu_membarrier_rperf_global_cxx.tap.in @@ -0,0 +1 @@ +./rcutorture_urcu_membarrier_cxx `@NPROC_CMD@` rperf 1 callrcu_global diff --git a/tests/regression/rcutorture_urcu_membarrier_rperf_percpu_cxx.tap.in b/tests/regression/rcutorture_urcu_membarrier_rperf_percpu_cxx.tap.in new file mode 100644 index 0000000..7514490 --- /dev/null +++ b/tests/regression/rcutorture_urcu_membarrier_rperf_percpu_cxx.tap.in @@ -0,0 +1 @@ +./rcutorture_urcu_membarrier_cxx `@NPROC_CMD@` rperf 1 callrcu_percpu diff --git a/tests/regression/rcutorture_urcu_membarrier_rperf_perthread_cxx.tap.in b/tests/regression/rcutorture_urcu_membarrier_rperf_perthread_cxx.tap.in new file mode 100644 index 0000000..e4ffe68 --- /dev/null +++ b/tests/regression/rcutorture_urcu_membarrier_rperf_perthread_cxx.tap.in @@ -0,0 +1 @@ +./rcutorture_urcu_membarrier_cxx `@NPROC_CMD@` rperf 1 callrcu_perthread diff --git a/tests/regression/rcutorture_urcu_membarrier_stress_global_cxx.tap.in b/tests/regression/rcutorture_urcu_membarrier_stress_global_cxx.tap.in new file mode 100644 index 0000000..9ac4415 --- /dev/null +++ b/tests/regression/rcutorture_urcu_membarrier_stress_global_cxx.tap.in @@ -0,0 +1 @@ +./rcutorture_urcu_membarrier_cxx `@NPROC_CMD@` stress 1 callrcu_global diff --git a/tests/regression/rcutorture_urcu_membarrier_stress_percpu_cxx.tap.in b/tests/regression/rcutorture_urcu_membarrier_stress_percpu_cxx.tap.in new file mode 100644 index 0000000..afcfc14 --- /dev/null +++ b/tests/regression/rcutorture_urcu_membarrier_stress_percpu_cxx.tap.in @@ -0,0 +1 @@ +./rcutorture_urcu_membarrier_cxx `@NPROC_CMD@` stress 1 callrcu_percpu diff --git a/tests/regression/rcutorture_urcu_membarrier_stress_perthread_cxx.tap.in b/tests/regression/rcutorture_urcu_membarrier_stress_perthread_cxx.tap.in new file mode 100644 index 0000000..0092a07 --- /dev/null +++ b/tests/regression/rcutorture_urcu_membarrier_stress_perthread_cxx.tap.in @@ -0,0 +1 @@ +./rcutorture_urcu_membarrier_cxx `@NPROC_CMD@` stress 1 callrcu_perthread diff --git a/tests/regression/rcutorture_urcu_membarrier_uperf_global_cxx.tap.in b/tests/regression/rcutorture_urcu_membarrier_uperf_global_cxx.tap.in new file mode 100644 index 0000000..0c675f1 --- /dev/null +++ b/tests/regression/rcutorture_urcu_membarrier_uperf_global_cxx.tap.in @@ -0,0 +1 @@ +./rcutorture_urcu_membarrier_cxx `@NPROC_CMD@` uperf 1 callrcu_global diff --git a/tests/regression/rcutorture_urcu_membarrier_uperf_percpu_cxx.tap.in b/tests/regression/rcutorture_urcu_membarrier_uperf_percpu_cxx.tap.in new file mode 100644 index 0000000..ab6372b --- /dev/null +++ b/tests/regression/rcutorture_urcu_membarrier_uperf_percpu_cxx.tap.in @@ -0,0 +1 @@ +./rcutorture_urcu_membarrier_cxx `@NPROC_CMD@` uperf 1 callrcu_percpu diff --git a/tests/regression/rcutorture_urcu_membarrier_uperf_perthread_cxx.tap.in b/tests/regression/rcutorture_urcu_membarrier_uperf_perthread_cxx.tap.in new file mode 100644 index 0000000..b521187 --- /dev/null +++ b/tests/regression/rcutorture_urcu_membarrier_uperf_perthread_cxx.tap.in @@ -0,0 +1 @@ +./rcutorture_urcu_membarrier_cxx `@NPROC_CMD@` uperf 1 callrcu_perthread diff --git a/tests/regression/rcutorture_urcu_qsbr_perf_global_cxx.tap.in b/tests/regression/rcutorture_urcu_qsbr_perf_global_cxx.tap.in new file mode 100644 index 0000000..facb3c7 --- /dev/null +++ b/tests/regression/rcutorture_urcu_qsbr_perf_global_cxx.tap.in @@ -0,0 +1 @@ +./rcutorture_urcu_qsbr_cxx `@NPROC_CMD@` perf 1 callrcu_global diff --git a/tests/regression/rcutorture_urcu_qsbr_perf_percpu_cxx.tap.in b/tests/regression/rcutorture_urcu_qsbr_perf_percpu_cxx.tap.in new file mode 100644 index 0000000..30cca48 --- /dev/null +++ b/tests/regression/rcutorture_urcu_qsbr_perf_percpu_cxx.tap.in @@ -0,0 +1 @@ +./rcutorture_urcu_qsbr_cxx `@NPROC_CMD@` perf 1 callrcu_percpu diff --git a/tests/regression/rcutorture_urcu_qsbr_perf_perthread_cxx.tap.in b/tests/regression/rcutorture_urcu_qsbr_perf_perthread_cxx.tap.in new file mode 100644 index 0000000..c461b6b --- /dev/null +++ b/tests/regression/rcutorture_urcu_qsbr_perf_perthread_cxx.tap.in @@ -0,0 +1 @@ +./rcutorture_urcu_qsbr_cxx `@NPROC_CMD@` perf 1 callrcu_perthread diff --git a/tests/regression/rcutorture_urcu_qsbr_rperf_global_cxx.tap.in b/tests/regression/rcutorture_urcu_qsbr_rperf_global_cxx.tap.in new file mode 100644 index 0000000..8c99091 --- /dev/null +++ b/tests/regression/rcutorture_urcu_qsbr_rperf_global_cxx.tap.in @@ -0,0 +1 @@ +./rcutorture_urcu_qsbr_cxx `@NPROC_CMD@` rperf 1 callrcu_global diff --git a/tests/regression/rcutorture_urcu_qsbr_rperf_percpu_cxx.tap.in b/tests/regression/rcutorture_urcu_qsbr_rperf_percpu_cxx.tap.in new file mode 100644 index 0000000..6a91581 --- /dev/null +++ b/tests/regression/rcutorture_urcu_qsbr_rperf_percpu_cxx.tap.in @@ -0,0 +1 @@ +./rcutorture_urcu_qsbr_cxx `@NPROC_CMD@` rperf 1 callrcu_percpu diff --git a/tests/regression/rcutorture_urcu_qsbr_rperf_perthread_cxx.tap.in b/tests/regression/rcutorture_urcu_qsbr_rperf_perthread_cxx.tap.in new file mode 100644 index 0000000..6d0baeb --- /dev/null +++ b/tests/regression/rcutorture_urcu_qsbr_rperf_perthread_cxx.tap.in @@ -0,0 +1 @@ +./rcutorture_urcu_qsbr_cxx `@NPROC_CMD@` rperf 1 callrcu_perthread diff --git a/tests/regression/rcutorture_urcu_qsbr_stress_global_cxx.tap.in b/tests/regression/rcutorture_urcu_qsbr_stress_global_cxx.tap.in new file mode 100644 index 0000000..e68b690 --- /dev/null +++ b/tests/regression/rcutorture_urcu_qsbr_stress_global_cxx.tap.in @@ -0,0 +1 @@ +./rcutorture_urcu_qsbr_cxx `@NPROC_CMD@` stress 1 callrcu_global diff --git a/tests/regression/rcutorture_urcu_qsbr_stress_percpu_cxx.tap.in b/tests/regression/rcutorture_urcu_qsbr_stress_percpu_cxx.tap.in new file mode 100644 index 0000000..f90fd19 --- /dev/null +++ b/tests/regression/rcutorture_urcu_qsbr_stress_percpu_cxx.tap.in @@ -0,0 +1 @@ +./rcutorture_urcu_qsbr_cxx `@NPROC_CMD@` stress 1 callrcu_percpu diff --git a/tests/regression/rcutorture_urcu_qsbr_stress_perthread_cxx.tap.in b/tests/regression/rcutorture_urcu_qsbr_stress_perthread_cxx.tap.in new file mode 100644 index 0000000..baaafb8 --- /dev/null +++ b/tests/regression/rcutorture_urcu_qsbr_stress_perthread_cxx.tap.in @@ -0,0 +1 @@ +./rcutorture_urcu_qsbr_cxx `@NPROC_CMD@` stress 1 callrcu_perthread diff --git a/tests/regression/rcutorture_urcu_qsbr_uperf_global_cxx.tap.in b/tests/regression/rcutorture_urcu_qsbr_uperf_global_cxx.tap.in new file mode 100644 index 0000000..4d89136 --- /dev/null +++ b/tests/regression/rcutorture_urcu_qsbr_uperf_global_cxx.tap.in @@ -0,0 +1 @@ +./rcutorture_urcu_qsbr_cxx `@NPROC_CMD@` uperf 1 callrcu_global diff --git a/tests/regression/rcutorture_urcu_qsbr_uperf_percpu_cxx.tap.in b/tests/regression/rcutorture_urcu_qsbr_uperf_percpu_cxx.tap.in new file mode 100644 index 0000000..70e5db0 --- /dev/null +++ b/tests/regression/rcutorture_urcu_qsbr_uperf_percpu_cxx.tap.in @@ -0,0 +1 @@ +./rcutorture_urcu_qsbr_cxx `@NPROC_CMD@` uperf 1 callrcu_percpu diff --git a/tests/regression/rcutorture_urcu_qsbr_uperf_perthread_cxx.tap.in b/tests/regression/rcutorture_urcu_qsbr_uperf_perthread_cxx.tap.in new file mode 100644 index 0000000..c45d43a --- /dev/null +++ b/tests/regression/rcutorture_urcu_qsbr_uperf_perthread_cxx.tap.in @@ -0,0 +1 @@ +./rcutorture_urcu_qsbr_cxx `@NPROC_CMD@` uperf 1 callrcu_perthread diff --git a/tests/regression/rcutorture_urcu_signal_perf_global_cxx.tap.in b/tests/regression/rcutorture_urcu_signal_perf_global_cxx.tap.in new file mode 100644 index 0000000..29778d1 --- /dev/null +++ b/tests/regression/rcutorture_urcu_signal_perf_global_cxx.tap.in @@ -0,0 +1 @@ +./rcutorture_urcu_signal_cxx `@NPROC_CMD@` perf 1 callrcu_global diff --git a/tests/regression/rcutorture_urcu_signal_perf_percpu_cxx.tap.in b/tests/regression/rcutorture_urcu_signal_perf_percpu_cxx.tap.in new file mode 100644 index 0000000..a2347e2 --- /dev/null +++ b/tests/regression/rcutorture_urcu_signal_perf_percpu_cxx.tap.in @@ -0,0 +1 @@ +./rcutorture_urcu_signal_cxx `@NPROC_CMD@` perf 1 callrcu_percpu diff --git a/tests/regression/rcutorture_urcu_signal_perf_perthread_cxx.tap.in b/tests/regression/rcutorture_urcu_signal_perf_perthread_cxx.tap.in new file mode 100644 index 0000000..eafda3e --- /dev/null +++ b/tests/regression/rcutorture_urcu_signal_perf_perthread_cxx.tap.in @@ -0,0 +1 @@ +./rcutorture_urcu_signal_cxx `@NPROC_CMD@` perf 1 callrcu_perthread diff --git a/tests/regression/rcutorture_urcu_signal_rperf_global_cxx.tap.in b/tests/regression/rcutorture_urcu_signal_rperf_global_cxx.tap.in new file mode 100644 index 0000000..ac3c022 --- /dev/null +++ b/tests/regression/rcutorture_urcu_signal_rperf_global_cxx.tap.in @@ -0,0 +1 @@ +./rcutorture_urcu_signal_cxx `@NPROC_CMD@` rperf 1 callrcu_global diff --git a/tests/regression/rcutorture_urcu_signal_rperf_percpu_cxx.tap.in b/tests/regression/rcutorture_urcu_signal_rperf_percpu_cxx.tap.in new file mode 100644 index 0000000..c18c2ff --- /dev/null +++ b/tests/regression/rcutorture_urcu_signal_rperf_percpu_cxx.tap.in @@ -0,0 +1 @@ +./rcutorture_urcu_signal_cxx `@NPROC_CMD@` rperf 1 callrcu_percpu diff --git a/tests/regression/rcutorture_urcu_signal_rperf_perthread_cxx.tap.in b/tests/regression/rcutorture_urcu_signal_rperf_perthread_cxx.tap.in new file mode 100644 index 0000000..273f219 --- /dev/null +++ b/tests/regression/rcutorture_urcu_signal_rperf_perthread_cxx.tap.in @@ -0,0 +1 @@ +./rcutorture_urcu_signal_cxx `@NPROC_CMD@` rperf 1 callrcu_perthread diff --git a/tests/regression/rcutorture_urcu_signal_stress_global_cxx.tap.in b/tests/regression/rcutorture_urcu_signal_stress_global_cxx.tap.in new file mode 100644 index 0000000..de8e4f6 --- /dev/null +++ b/tests/regression/rcutorture_urcu_signal_stress_global_cxx.tap.in @@ -0,0 +1 @@ +./rcutorture_urcu_signal_cxx `@NPROC_CMD@` stress 1 callrcu_global diff --git a/tests/regression/rcutorture_urcu_signal_stress_percpu_cxx.tap.in b/tests/regression/rcutorture_urcu_signal_stress_percpu_cxx.tap.in new file mode 100644 index 0000000..032117c --- /dev/null +++ b/tests/regression/rcutorture_urcu_signal_stress_percpu_cxx.tap.in @@ -0,0 +1 @@ +./rcutorture_urcu_signal_cxx `@NPROC_CMD@` stress 1 callrcu_percpu diff --git a/tests/regression/rcutorture_urcu_signal_stress_perthread_cxx.tap.in b/tests/regression/rcutorture_urcu_signal_stress_perthread_cxx.tap.in new file mode 100644 index 0000000..e8227f3 --- /dev/null +++ b/tests/regression/rcutorture_urcu_signal_stress_perthread_cxx.tap.in @@ -0,0 +1 @@ +./rcutorture_urcu_signal_cxx `@NPROC_CMD@` stress 1 callrcu_perthread diff --git a/tests/regression/rcutorture_urcu_signal_uperf_global_cxx.tap.in b/tests/regression/rcutorture_urcu_signal_uperf_global_cxx.tap.in new file mode 100644 index 0000000..c6c096f --- /dev/null +++ b/tests/regression/rcutorture_urcu_signal_uperf_global_cxx.tap.in @@ -0,0 +1 @@ +./rcutorture_urcu_signal_cxx `@NPROC_CMD@` uperf 1 callrcu_global diff --git a/tests/regression/rcutorture_urcu_signal_uperf_percpu_cxx.tap.in b/tests/regression/rcutorture_urcu_signal_uperf_percpu_cxx.tap.in new file mode 100644 index 0000000..d50ec28 --- /dev/null +++ b/tests/regression/rcutorture_urcu_signal_uperf_percpu_cxx.tap.in @@ -0,0 +1 @@ +./rcutorture_urcu_signal_cxx `@NPROC_CMD@` uperf 1 callrcu_percpu diff --git a/tests/regression/rcutorture_urcu_signal_uperf_perthread_cxx.tap.in b/tests/regression/rcutorture_urcu_signal_uperf_perthread_cxx.tap.in new file mode 100644 index 0000000..570a0d8 --- /dev/null +++ b/tests/regression/rcutorture_urcu_signal_uperf_perthread_cxx.tap.in @@ -0,0 +1 @@ +./rcutorture_urcu_signal_cxx `@NPROC_CMD@` uperf 1 callrcu_perthread diff --git a/tests/regression/test_urcu_fork.c b/tests/regression/test_urcu_fork.c index 81dbe77..db4e81d 100644 --- a/tests/regression/test_urcu_fork.c +++ b/tests/regression/test_urcu_fork.c @@ -88,7 +88,7 @@ static void test_rcu(void) rcu_read_lock(); rcu_read_unlock(); - node = malloc(sizeof(*node)); + node = (struct test_node *) malloc(sizeof(*node)); urcu_posix_assert(node); call_rcu(&node->head, cb); diff --git a/tests/regression/test_urcu_fork_cxx.cpp b/tests/regression/test_urcu_fork_cxx.cpp new file mode 100644 index 0000000..8c87220 --- /dev/null +++ b/tests/regression/test_urcu_fork_cxx.cpp @@ -0,0 +1,3 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later */ + +#include "test_urcu_fork.c" diff --git a/tests/regression/urcutorture_cxx.cpp b/tests/regression/urcutorture_cxx.cpp new file mode 100644 index 0000000..ab4e582 --- /dev/null +++ b/tests/regression/urcutorture_cxx.cpp @@ -0,0 +1,3 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later */ + +#include "urcutorture.c" diff --git a/tests/unit/Makefile.am b/tests/unit/Makefile.am index ef73127..119dc73 100644 --- a/tests/unit/Makefile.am +++ b/tests/unit/Makefile.am @@ -6,11 +6,17 @@ LOG_DRIVER = env AM_TAP_AWK='$(AWK)' $(SHELL) \ noinst_PROGRAMS = \ test_arch \ + test_arch_cxx \ test_uatomic \ + test_uatomic_cxx \ test_urcu_multiflavor \ + test_urcu_multiflavor_cxx \ test_urcu_multiflavor_dynlink \ + test_urcu_multiflavor_dynlink_cxx \ test_urcu_multiflavor_single_unit \ - test_urcu_multiflavor_single_unit_dynlink + test_urcu_multiflavor_single_unit_cxx \ + test_urcu_multiflavor_single_unit_dynlink \ + test_urcu_multiflavor_single_unit_dynlink_cxx TESTS = $(noinst_PROGRAMS) @@ -28,9 +34,15 @@ TAP_LIB=$(top_builddir)/tests/utils/libtap.a test_arch_SOURCES = test_arch.c test_arch_LDADD = $(URCU_COMMON_LIB) $(TAP_LIB) +test_arch_cxx_SOURCES = test_arch_cxx.cpp +test_arch_cxx_LDADD = $(URCU_COMMO_LIB) $(TAP_LIB) + test_uatomic_SOURCES = test_uatomic.c test_uatomic_LDADD = $(URCU_COMMON_LIB) $(TAP_LIB) +test_uatomic_cxx_SOURCES = test_uatomic_cxx.cpp +test_uatomic_cxx_LDADD = $(URCU_COMMON_LIB) $(TAP_LIB) + test_urcu_multiflavor_SOURCES = test_urcu_multiflavor.c \ test_urcu_multiflavor-memb.c \ test_urcu_multiflavor-mb.c \ @@ -40,6 +52,15 @@ test_urcu_multiflavor_SOURCES = test_urcu_multiflavor.c \ test_urcu_multiflavor_LDADD = $(URCU_LIB) $(URCU_MB_LIB) \ $(URCU_SIGNAL_LIB) $(URCU_QSBR_LIB) $(URCU_BP_LIB) $(TAP_LIB) +test_urcu_multiflavor_cxx_SOURCES = test_urcu_multiflavor_cxx.cpp \ + test_urcu_multiflavor-memb_cxx.cpp \ + test_urcu_multiflavor-mb_cxx.cpp \ + test_urcu_multiflavor-signal_cxx.cpp \ + test_urcu_multiflavor-qsbr_cxx.cpp \ + test_urcu_multiflavor-bp_cxx.cpp +test_urcu_multiflavor_cxx_LDADD = $(URCU_LIB) $(URCU_MB_LIB) \ + $(URCU_SIGNAL_LIB) $(URCU_QSBR_LIB) $(URCU_BP_LIB) $(TAP_LIB) + test_urcu_multiflavor_dynlink_SOURCES = test_urcu_multiflavor.c \ test_urcu_multiflavor-memb.c \ test_urcu_multiflavor-mb.c \ @@ -50,15 +71,34 @@ test_urcu_multiflavor_dynlink_CFLAGS = -DDYNAMIC_LINK_TEST $(AM_CFLAGS) test_urcu_multiflavor_dynlink_LDADD = $(URCU_LIB) $(URCU_MB_LIB) \ $(URCU_SIGNAL_LIB) $(URCU_QSBR_LIB) $(URCU_BP_LIB) $(TAP_LIB) +test_urcu_multiflavor_dynlink_cxx_SOURCES = test_urcu_multiflavor_cxx.cpp \ + test_urcu_multiflavor-memb_cxx.cpp \ + test_urcu_multiflavor-mb_cxx.cpp \ + test_urcu_multiflavor-signal_cxx.cpp \ + test_urcu_multiflavor-qsbr_cxx.cpp \ + test_urcu_multiflavor-bp_cxx.cpp +test_urcu_multiflavor_dynlink_cxx_CXXFLAGS = -DDYNAMIC_LINK_TEST $(AM_CXXFLAGS) +test_urcu_multiflavor_dynlink_cxx_LDADD = $(URCU_LIB) $(URCU_MB_LIB) \ + $(URCU_SIGNAL_LIB) $(URCU_QSBR_LIB) $(URCU_BP_LIB) $(TAP_LIB) + test_urcu_multiflavor_single_unit_SOURCES = test_urcu_multiflavor_single_unit.c test_urcu_multiflavor_single_unit_LDADD = $(URCU_LIB) $(URCU_MB_LIB) \ $(URCU_SIGNAL_LIB) $(URCU_QSBR_LIB) $(URCU_BP_LIB) $(TAP_LIB) +test_urcu_multiflavor_single_unit_cxx_SOURCES = test_urcu_multiflavor_single_unit_cxx.cpp +test_urcu_multiflavor_single_unit_cxx_LDADD = $(URCU_LIB) $(URCU_MB_LIB) \ + $(URCU_SIGNAL_LIB) $(URCU_QSBR_LIB) $(URCU_BP_LIB) $(TAP_LIB) + test_urcu_multiflavor_single_unit_dynlink_SOURCES = test_urcu_multiflavor_single_unit.c test_urcu_multiflavor_single_unit_dynlink_CFLAGS = -DDYNAMIC_LINK_TEST $(AM_CFLAGS) test_urcu_multiflavor_single_unit_dynlink_LDADD = $(URCU_LIB) $(URCU_MB_LIB) \ $(URCU_SIGNAL_LIB) $(URCU_QSBR_LIB) $(URCU_BP_LIB) $(TAP_LIB) +test_urcu_multiflavor_single_unit_dynlink_cxx_SOURCES = test_urcu_multiflavor_single_unit_cxx.cpp +test_urcu_multiflavor_single_unit_dynlink_cxx_CXXFLAGS = -DDYNAMIC_LINK_TEST $(AM_CXXFLAGS) +test_urcu_multiflavor_single_unit_dynlink_cxx_LDADD = $(URCU_LIB) $(URCU_MB_LIB) \ + $(URCU_SIGNAL_LIB) $(URCU_QSBR_LIB) $(URCU_BP_LIB) $(TAP_LIB) + all-local: @if [ x"$(srcdir)" != x"$(builddir)" ]; then \ for script in $(SCRIPT_LIST); do \ diff --git a/tests/unit/test_arch_cxx.cpp b/tests/unit/test_arch_cxx.cpp new file mode 100644 index 0000000..5aa9d98 --- /dev/null +++ b/tests/unit/test_arch_cxx.cpp @@ -0,0 +1,3 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later */ + +#include "test_arch.c" diff --git a/tests/unit/test_uatomic_cxx.cpp b/tests/unit/test_uatomic_cxx.cpp new file mode 100644 index 0000000..c5ad40d --- /dev/null +++ b/tests/unit/test_uatomic_cxx.cpp @@ -0,0 +1,3 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later */ + +#include "test_uatomic.c" diff --git a/tests/unit/test_urcu_multiflavor-bp_cxx.cpp b/tests/unit/test_urcu_multiflavor-bp_cxx.cpp new file mode 100644 index 0000000..65bb67c --- /dev/null +++ b/tests/unit/test_urcu_multiflavor-bp_cxx.cpp @@ -0,0 +1,3 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later */ + +#include "test_urcu_multiflavor-bp.c" diff --git a/tests/unit/test_urcu_multiflavor-mb_cxx.cpp b/tests/unit/test_urcu_multiflavor-mb_cxx.cpp new file mode 100644 index 0000000..606b66d --- /dev/null +++ b/tests/unit/test_urcu_multiflavor-mb_cxx.cpp @@ -0,0 +1,3 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later */ + +#include "test_urcu_multiflavor-mb.c" diff --git a/tests/unit/test_urcu_multiflavor-memb_cxx.cpp b/tests/unit/test_urcu_multiflavor-memb_cxx.cpp new file mode 100644 index 0000000..adda7d0 --- /dev/null +++ b/tests/unit/test_urcu_multiflavor-memb_cxx.cpp @@ -0,0 +1,3 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later */ + +#include "test_urcu_multiflavor-memb.c" diff --git a/tests/unit/test_urcu_multiflavor-qsbr_cxx.cpp b/tests/unit/test_urcu_multiflavor-qsbr_cxx.cpp new file mode 100644 index 0000000..a4039ed --- /dev/null +++ b/tests/unit/test_urcu_multiflavor-qsbr_cxx.cpp @@ -0,0 +1,3 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later */ + +#include "test_urcu_multiflavor-qsbr.c" diff --git a/tests/unit/test_urcu_multiflavor-signal_cxx.cpp b/tests/unit/test_urcu_multiflavor-signal_cxx.cpp new file mode 100644 index 0000000..0f77550 --- /dev/null +++ b/tests/unit/test_urcu_multiflavor-signal_cxx.cpp @@ -0,0 +1,3 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later */ + +#include "test_urcu_multiflavor-signal.c" diff --git a/tests/unit/test_urcu_multiflavor_cxx.cpp b/tests/unit/test_urcu_multiflavor_cxx.cpp new file mode 100644 index 0000000..5a370b3 --- /dev/null +++ b/tests/unit/test_urcu_multiflavor_cxx.cpp @@ -0,0 +1,3 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later */ + +#include "test_urcu_multiflavor.c" diff --git a/tests/unit/test_urcu_multiflavor_single_unit_cxx.cpp b/tests/unit/test_urcu_multiflavor_single_unit_cxx.cpp new file mode 100644 index 0000000..ff06d6d --- /dev/null +++ b/tests/unit/test_urcu_multiflavor_single_unit_cxx.cpp @@ -0,0 +1,3 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later */ + +#include "test_urcu_multiflavor_single_unit.c" diff --git a/tests/unit/urcu-asm_cxx.cpp b/tests/unit/urcu-asm_cxx.cpp new file mode 100644 index 0000000..efba54c --- /dev/null +++ b/tests/unit/urcu-asm_cxx.cpp @@ -0,0 +1,3 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later */ + +#include "urcu-asm.c" diff --git a/tests/utils/tap.h b/tests/utils/tap.h index 39312fc..3000177 100644 --- a/tests/utils/tap.h +++ b/tests/utils/tap.h @@ -5,6 +5,10 @@ * Copyright (C) 2017 Jérémie Galarneau */ +#ifdef __cplusplus +extern "C" { +#endif + /* '## __VA_ARGS__' is a gcc'ism. C99 doesn't allow the token pasting and requires the caller to add the final comma if they've ommitted the optional arguments */ @@ -87,3 +91,7 @@ unsigned int rdiag_start(void); __attribute__((format(TAP_PRINTF_FORMAT, 1, 2))) unsigned int rdiag(const char *fmt, ...); unsigned int rdiag_end(void); + +#ifdef __cplusplus +} +#endif -- 2.34.1