diff options
author | Eric Fiselier <eric@efcs.ca> | 2015-04-02 21:02:06 +0000 |
---|---|---|
committer | Eric Fiselier <eric@efcs.ca> | 2015-04-02 21:02:06 +0000 |
commit | 1d55ecf51364279841f140f0255af8f496a7ee3f (patch) | |
tree | 9ae2e90809547080039834cee7d4022730f64cfb | |
parent | 2cea80b137cb6e6bbadc5f0461220547f351461f (diff) |
[libcxx] Fix bug in shared_timed_mutex that could cause a program to hang.
Summary:
The summary of the bug, provided by Stephan T. Lavavej:
In shared_timed_mutex::try_lock_until() (line 195 in 3.6.0), you need to deliver a notification. The scenario is:
* There are N threads holding the shared lock.
* One thread calls try_lock_until() to attempt to acquire the exclusive lock. It sets the "I want to write" bool/bit, then waits for the N readers to drain away.
* K more threads attempt to acquire the shared lock, but they notice that someone said "I want to write", so they block on a condition_variable.
* At least one of the N readers is stubborn and doesn't release the shared lock.
* The wannabe-writer times out, gives up, and unsets the "I want to write" bool/bit.
At this point, a notification (it needs to be notify_all) must be delivered to the condition_variable that the K wannabe-readers are waiting on. Otherwise, they can block forever without waking up.
Reviewers: mclow.lists, jyasskin
Reviewed By: jyasskin
Subscribers: jyasskin, cfe-commits
Differential Revision: http://reviews.llvm.org/D8796
git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@233944 91177308-0d34-0410-b5e6-96231b3b80d8
2 files changed, 71 insertions, 0 deletions
diff --git a/include/shared_mutex b/include/shared_mutex index 9b7f0bf77..c97b147ef 100644 --- a/include/shared_mutex +++ b/include/shared_mutex @@ -193,6 +193,7 @@ shared_timed_mutex::try_lock_until( if (__status == cv_status::timeout) { __state_ &= ~__write_entered_; + __gate1_.notify_all(); return false; } } diff --git a/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_until_deadlock_bug.pass.cpp b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_until_deadlock_bug.pass.cpp new file mode 100644 index 000000000..ed288099c --- /dev/null +++ b/test/std/thread/thread.mutex/thread.mutex.requirements/thread.sharedtimedmutex.requirements/thread.sharedtimedmutex.class/try_lock_until_deadlock_bug.pass.cpp @@ -0,0 +1,70 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +// +// UNSUPPORTED: libcpp-has-no-threads +// UNSUPPORTED: c++03, c++98, c++11 + +// <shared_mutex> + +// class shared_timed_mutex; + +#include <shared_mutex> + +#include <atomic> +#include <chrono> +#include <thread> +#include <cstdlib> +#include <cassert> + +std::shared_timed_mutex m; + +const int total_readers = 2; +std::atomic<int> readers_started(0); +std::atomic<int> readers_finished(0); + +// Wait for the readers to start then try and acquire the write lock. +void writer_one() { + while (readers_started != total_readers) {} + bool b = m.try_lock_for(std::chrono::milliseconds(500)); + assert(b == false); +} + +void blocked_reader() { + ++readers_started; + // Wait until writer_one is waiting for the write lock. + while (m.try_lock_shared()) { + m.unlock_shared(); + } + // Attempt to get the read lock. writer_one should be blocking us because + // writer_one is blocked by main. + m.lock_shared(); + ++readers_finished; + m.unlock_shared(); +} + +int main() +{ + typedef std::chrono::steady_clock Clock; + + m.lock_shared(); + std::thread t1(writer_one); + // create some readers + std::thread t2(blocked_reader); + std::thread t3(blocked_reader); + // Kill the test after 10 seconds if it hasn't completed. + auto end_point = Clock::now() + std::chrono::seconds(10); + while (readers_finished != total_readers && Clock::now() < end_point) { + std::this_thread::sleep_for(std::chrono::seconds(1)); + } + assert(readers_finished == total_readers); + m.unlock_shared(); + t1.join(); + t2.join(); + t3.join(); +} |