[PATCHv3,1/6] Improve libstdc++-v3 async test

Message ID 20180801131913.6576-2-mac@mcrowe.com
State New
Headers show
Series
  • std::future::wait_* improvements
Related show

Commit Message

Mike Crowe Aug. 1, 2018, 1:19 p.m.
Add tests for waiting for the future using both std::chrono::steady_clock
and std::chrono::system_clock in preparation for dealing with those clocks
properly in futex.cc.
---
 libstdc++-v3/testsuite/30_threads/async/async.cc | 33 ++++++++++++++++++++++++
 1 file changed, 33 insertions(+)

--
2.11.0

BrightSign considers your privacy to be very important. The emails you send to us will be protected and secured. Furthermore, we will only use your email and contact information for the reasons you sent them to us and for tracking how effectively we respond to your requests.

Comments

Jonathan Wakely Aug. 1, 2018, 4:39 p.m. | #1
On 01/08/18 14:19 +0100, Mike Crowe wrote:
>Add tests for waiting for the future using both std::chrono::steady_clock

>and std::chrono::system_clock in preparation for dealing with those clocks

>properly in futex.cc.

>---

> libstdc++-v3/testsuite/30_threads/async/async.cc | 33 ++++++++++++++++++++++++

> 1 file changed, 33 insertions(+)

>

>diff --git a/libstdc++-v3/testsuite/30_threads/async/async.cc b/libstdc++-v3/testsuite/30_threads/async/async.cc

>index 4c2cdd1a534..015bcce0c2c 100644

>--- a/libstdc++-v3/testsuite/30_threads/async/async.cc

>+++ b/libstdc++-v3/testsuite/30_threads/async/async.cc

>@@ -51,17 +51,50 @@ void test02()

>   VERIFY( status == std::future_status::timeout );

>   status = f1.wait_until(std::chrono::system_clock::now());

>   VERIFY( status == std::future_status::timeout );

>+  status = f1.wait_until(std::chrono::steady_clock::now());

>+  VERIFY( status == std::future_status::timeout );

>   l.unlock();  // allow async thread to proceed

>   f1.wait();   // wait for it to finish

>   status = f1.wait_for(std::chrono::milliseconds(0));

>   VERIFY( status == std::future_status::ready );

>   status = f1.wait_until(std::chrono::system_clock::now());

>   VERIFY( status == std::future_status::ready );

>+  status = f1.wait_until(std::chrono::steady_clock::now());

>+  VERIFY( status == std::future_status::ready );

>+}

>+

>+// This test is prone to failures if run on a loaded machine where the

>+// kernel decides not to schedule us for several seconds. It also

>+// assumes that no-one will warp CLOCK whilst the test is

>+// running.

>+template<typename CLOCK>

>+void test03()

>+{

>+  auto const start = CLOCK::now();

>+  future<void> f1 = async(launch::async, []() {

>+      std::this_thread::sleep_for(std::chrono::seconds(2));


Thanks for reducing these times since the last patch. I think this
test improvement can go on trunk, and if we see too many failures we
can adjust the times.

Patch

diff --git a/libstdc++-v3/testsuite/30_threads/async/async.cc b/libstdc++-v3/testsuite/30_threads/async/async.cc
index 4c2cdd1a534..015bcce0c2c 100644
--- a/libstdc++-v3/testsuite/30_threads/async/async.cc
+++ b/libstdc++-v3/testsuite/30_threads/async/async.cc
@@ -51,17 +51,50 @@  void test02()
   VERIFY( status == std::future_status::timeout );
   status = f1.wait_until(std::chrono::system_clock::now());
   VERIFY( status == std::future_status::timeout );
+  status = f1.wait_until(std::chrono::steady_clock::now());
+  VERIFY( status == std::future_status::timeout );
   l.unlock();  // allow async thread to proceed
   f1.wait();   // wait for it to finish
   status = f1.wait_for(std::chrono::milliseconds(0));
   VERIFY( status == std::future_status::ready );
   status = f1.wait_until(std::chrono::system_clock::now());
   VERIFY( status == std::future_status::ready );
+  status = f1.wait_until(std::chrono::steady_clock::now());
+  VERIFY( status == std::future_status::ready );
+}
+
+// This test is prone to failures if run on a loaded machine where the
+// kernel decides not to schedule us for several seconds. It also
+// assumes that no-one will warp CLOCK whilst the test is
+// running.
+template<typename CLOCK>
+void test03()
+{
+  auto const start = CLOCK::now();
+  future<void> f1 = async(launch::async, []() {
+      std::this_thread::sleep_for(std::chrono::seconds(2));
+    });
+  std::future_status status;
+
+  status = f1.wait_for(std::chrono::milliseconds(500));
+  VERIFY( status == std::future_status::timeout );
+
+  status = f1.wait_until(start + std::chrono::seconds(1));
+  VERIFY( status == std::future_status::timeout );
+
+  status = f1.wait_until(start + std::chrono::seconds(5));
+  VERIFY( status == std::future_status::ready );
+
+  auto const elapsed = CLOCK::now() - start;
+  VERIFY( elapsed >= std::chrono::seconds(2) );
+  VERIFY( elapsed < std::chrono::seconds(5) );
 }

 int main()
 {
   test01();
   test02();
+  test03<std::chrono::system_clock>();
+  test03<std::chrono::steady_clock>();
   return 0;
 }