From 8c4e33d2032ab150748ea2fe1df2b1c00652a338 Mon Sep 17 00:00:00 2001 From: Jonathan Wakely Date: Fri, 13 Nov 2020 10:04:33 +0000 Subject: [PATCH] libstdc++: Add -pthread options to std::future polling test For linux targets this test doesn't need -lpthread because it only uses atomics, but for all other targets std::call_once still needs pthreads. Add the necessary test directives to make that work. The timings in this test might be too fragile or too target-specific, so it might need to be adjusted in future, or restricted to only run on specific targets. For now I've increased the allowed ratio between wait_for calls before and after the future is made ready, because it was failing with -O3 -march=native sometimes. libstdc++-v3/ChangeLog: * testsuite/30_threads/future/members/poll.cc: Require gthreads and add -pthread for targets that require it. Relax required ratio of wait_for calls before/after the future is ready. --- .../30_threads/future/members/poll.cc | 40 ++++++++++--------- 1 file changed, 21 insertions(+), 19 deletions(-) diff --git a/libstdc++-v3/testsuite/30_threads/future/members/poll.cc b/libstdc++-v3/testsuite/30_threads/future/members/poll.cc index 54580579d3a..fff9bea899c 100644 --- a/libstdc++-v3/testsuite/30_threads/future/members/poll.cc +++ b/libstdc++-v3/testsuite/30_threads/future/members/poll.cc @@ -17,6 +17,8 @@ // { dg-options "-O3" } // { dg-do run { target c++11 } } +// { dg-additional-options "-pthread" { target pthread } } +// { dg-require-gthreads "" } #include #include @@ -51,31 +53,31 @@ int main() start = chrono::high_resolution_clock::now(); for(int i = 0; i < iterations; i++) - f.wait_until(chrono::system_clock::time_point()); + f.wait_until(chrono::system_clock::time_point::min()); stop = chrono::high_resolution_clock::now(); - double wait_until_sys_epoch __attribute__((unused)) - = print("wait_until(system_clock epoch)", stop - start); + double wait_until_sys_min __attribute__((unused)) + = print("wait_until(system_clock minimum)", stop - start); start = chrono::high_resolution_clock::now(); for(int i = 0; i < iterations; i++) - f.wait_until(chrono::steady_clock::time_point()); + f.wait_until(chrono::steady_clock::time_point::min()); stop = chrono::high_resolution_clock::now(); - double wait_until_steady_epoch __attribute__((unused)) - = print("wait_until(steady_clock epoch", stop - start); + double wait_until_steady_min __attribute__((unused)) + = print("wait_until(steady_clock minimum)", stop - start); start = chrono::high_resolution_clock::now(); for(int i = 0; i < iterations; i++) - f.wait_until(chrono::system_clock::time_point::min()); + f.wait_until(chrono::system_clock::time_point()); stop = chrono::high_resolution_clock::now(); - double wait_until_sys_min __attribute__((unused)) - = print("wait_until(system_clock minimum)", stop - start); + double wait_until_sys_epoch __attribute__((unused)) + = print("wait_until(system_clock epoch)", stop - start); start = chrono::high_resolution_clock::now(); for(int i = 0; i < iterations; i++) - f.wait_until(chrono::steady_clock::time_point::min()); + f.wait_until(chrono::steady_clock::time_point()); stop = chrono::high_resolution_clock::now(); - double wait_until_steady_min __attribute__((unused)) - = print("wait_until(steady_clock minimum)", stop - start); + double wait_until_steady_epoch __attribute__((unused)) + = print("wait_until(steady_clock epoch", stop - start); p.set_value(1); @@ -85,19 +87,19 @@ int main() stop = chrono::high_resolution_clock::now(); double ready = print("wait_for when ready", stop - start); - // polling before ready with wait_for(0s) should be almost as fast as + // Polling before ready with wait_for(0s) should be almost as fast as // after the result is ready. - VERIFY( wait_for_0 < (ready * 10) ); + VERIFY( wait_for_0 < (ready * 30) ); + + // Polling before ready using wait_until(min) should not be terribly slow. + VERIFY( wait_until_sys_min < (ready * 100) ); + VERIFY( wait_until_steady_min < (ready * 100) ); // The following two tests fail with GCC 11, see // https://gcc.gnu.org/pipermail/libstdc++/2020-November/051422.html #if 0 - // polling before ready using wait_until(epoch) should not be terribly slow. + // Polling before ready using wait_until(epoch) should not be terribly slow. VERIFY( wait_until_sys_epoch < (ready * 100) ); VERIFY( wait_until_steady_epoch < (ready * 100) ); #endif - - // polling before ready using wait_until(min) should not be terribly slow. - VERIFY( wait_until_sys_min < (ready * 100) ); - VERIFY( wait_until_steady_min < (ready * 100) ); } -- 2.30.2