commit c6ffd1648328a4f2f2bbaac11378725c08409a95
Author: Jonathan Wakely <jwakely@redhat.com>
Date: Thu Mar 5 23:43:08 2015 +0000
PR libstdc++/58038
PR libstdc++/60421
* include/std/thread (this_thread::sleep_for): Check for negative
durations.
(this_thread::sleep_until): Check for times in the past.
* testsuite/30_threads/this_thread/58038.cc: New.
* testsuite/30_threads/this_thread/60421.cc: New.
@@ -279,6 +279,8 @@ _GLIBCXX_END_NAMESPACE_VERSION
inline void
sleep_for(const chrono::duration<_Rep, _Period>& __rtime)
{
+ if (__rtime <= __rtime.zero())
+ return;
auto __s = chrono::duration_cast<chrono::seconds>(__rtime);
auto __ns = chrono::duration_cast<chrono::nanoseconds>(__rtime - __s);
#ifdef _GLIBCXX_USE_NANOSLEEP
@@ -297,7 +299,11 @@ _GLIBCXX_END_NAMESPACE_VERSION
template<typename _Clock, typename _Duration>
inline void
sleep_until(const chrono::time_point<_Clock, _Duration>& __atime)
- { sleep_for(__atime - _Clock::now()); }
+ {
+ auto __now = _Clock::now();
+ if (__now < __atime)
+ sleep_for(__atime - __now);
+ }
_GLIBCXX_END_NAMESPACE_VERSION
}
new file mode 100644
@@ -0,0 +1,44 @@
+// Copyright (C) 2015 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+// { dg-options "-std=gnu++11" }
+// { dg-require-cstdint "" }
+// { dg-require-time "" }
+
+#include <thread>
+#include <chrono>
+
+void
+test01()
+{
+ auto now = std::chrono::system_clock::now();
+ std::this_thread::sleep_until(now - 1ul * std::chrono::seconds(1));
+}
+
+void
+test02()
+{
+ auto now = std::chrono::steady_clock::now();
+ std::this_thread::sleep_until(now - 1ul * std::chrono::seconds(1));
+}
+
+int
+main()
+{
+ test01();
+ test02();
+}
new file mode 100644
@@ -0,0 +1,38 @@
+// Copyright (C) 2015 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3. If not see
+// <http://www.gnu.org/licenses/>.
+
+// { dg-options "-std=gnu++11" }
+// { dg-require-cstdint "" }
+// { dg-require-time "" }
+
+#include <thread>
+#include <chrono>
+#include <testsuite_hooks.h>
+
+void
+test01()
+{
+ std::this_thread::sleep_for(std::chrono::seconds(0));
+ std::this_thread::sleep_for(std::chrono::seconds(-1));
+ std::this_thread::sleep_for(std::chrono::duration<uint64_t>::zero());
+}
+
+int
+main()
+{
+ test01();
+}
We have a couple of bugs where durations with unsigned representations result in negative or huge time_t values, which result in not sleeping at all or sleeping for billions of years (or merely for decades if you have a 32-bit time_t). This change simply returns early for time points in the past or negative durations. Tested x86_64-linux, powerpc64le-linux, committed to trunk. For stage 1 ... We can still overflow in this_thread::sleep_for() here: auto __s = chrono::duration_cast<chrono::seconds>(__rtime); if __rtime uses a uint64_t rep and has a value larger than chrono::seconds::max(), and also here: static_cast<std::time_t>(__s.count()), if time_t is 32-bit and __s has a value larger than it can hold. We should limit the __s value to duration<time_t>::max() but detecting those overflows reliably is more complicated than we can manage for gcc5, and only happens for crazy durations anyway. We should also handle nanosleep() returning early and setting EINTR, and also loop in sleep_until() to handle clock adjustments: auto __now = _Clock::now(); if (_Clock::is_steady) { if (__now < __atime) sleep_for(__atime - __now); return; } while (__now < __atime) { sleep_for(__atime - __now); __now = _Clock::now(); } I also need to finish reviewing <condition_variable>, <mutex> and <shared_mutex> for similar problems.