OpenE2K/gcc
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

libstdc++: Add -pthread options to std::future polling test

Browse Source 
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.
This commit is contained in:
Jonathan Wakely 2020-11-13 10:04:33 +00:00
parent 54bbde550e
commit 8c4e33d203
1 changed files with 23 additions and 21 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

44
libstdc++-v3/testsuite/30_threads/future/members/poll.cc
View File

@ -17,6 +17,8 @@
// { dg-options "-O3" }
// { dg-do run { target c++11 } }
// { dg-additional-options "-pthread" { target pthread } }
// { dg-require-gthreads "" }
#include <future>
#include <chrono>
@ -49,20 +51,6 @@ int main()
auto stop = chrono::high_resolution_clock::now();
double wait_for_0 = print("wait_for(0s)", stop - start);
start = chrono::high_resolution_clock::now();
for(int i = 0; i < iterations; i++)
f.wait_until(chrono::system_clock::time_point());
stop = chrono::high_resolution_clock::now();
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());
stop = chrono::high_resolution_clock::now();
double wait_until_steady_epoch __attribute__((unused))
= print("wait_until(steady_clock epoch", stop - start);
start = chrono::high_resolution_clock::now();
for(int i = 0; i < iterations; i++)
f.wait_until(chrono::system_clock::time_point::min());
@ -77,6 +65,20 @@ int main()
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());
stop = chrono::high_resolution_clock::now();
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());
stop = chrono::high_resolution_clock::now();
double wait_until_steady_epoch __attribute__((unused))
= print("wait_until(steady_clock epoch", stop - start);
p.set_value(1);
start = chrono::high_resolution_clock::now();
@ -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) );
}