From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: by sourceware.org (Postfix, from userid 2181) id EDF8D3857C5A; Fri, 13 Nov 2020 11:01:37 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org EDF8D3857C5A Content-Type: text/plain; charset="us-ascii" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit From: Jonathan Wakely To: gcc-cvs@gcc.gnu.org, libstdc++-cvs@gcc.gnu.org Subject: [gcc r11-4974] libstdc++: Add -pthread options to std::future polling test X-Act-Checkin: gcc X-Git-Author: Jonathan Wakely X-Git-Refname: refs/heads/master X-Git-Oldrev: 54bbde550ec557e48a67ca1f4036e46710bcfeda X-Git-Newrev: 8c4e33d2032ab150748ea2fe1df2b1c00652a338 Message-Id: <20201113110137.EDF8D3857C5A@sourceware.org> Date: Fri, 13 Nov 2020 11:01:37 +0000 (GMT) X-BeenThere: libstdc++-cvs@gcc.gnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Libstdc++-cvs mailing list List-Unsubscribe: , List-Archive: List-Help: List-Subscribe: , X-List-Received-Date: Fri, 13 Nov 2020 11:01:38 -0000 https://gcc.gnu.org/g:8c4e33d2032ab150748ea2fe1df2b1c00652a338 commit r11-4974-g8c4e33d2032ab150748ea2fe1df2b1c00652a338 Author: Jonathan Wakely Date: Fri Nov 13 10:04:33 2020 +0000 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. Diff: --- .../testsuite/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) ); }