Skip to content

[libc++] Make std::unique_lock available with _LIBCPP_HAS_NO_THREADS #99562

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 9 commits into from
Jul 31, 2024
Merged

[libc++] Make std::unique_lock available with _LIBCPP_HAS_NO_THREADS #99562

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
9 commits
Select commit Hold shift + click to select a range
519b828
[𝘀𝗽𝗿] initial version
ilovepi Jul 18, 2024
348ded7
Update commit message and rebase
ilovepi Jul 19, 2024
1d21ae1
Remove no-threads from some files I missed
ilovepi Jul 24, 2024
5d40130
Update test to be a compile test
ilovepi Jul 24, 2024
83cf9ff
Add missing header for chrono
ilovepi Jul 25, 2024
3bc709e
Swap stead_clock for system_clock to satisfy bots
ilovepi Jul 26, 2024
49dd5d1
Update error code checks
ilovepi Jul 30, 2024
f40ffce
Update error codes in test checks
ilovepi Jul 30, 2024
85e3bfc
git clang-format
ilovepi Jul 30, 2024
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
4 changes: 0 additions & 4 deletions libcxx/include/__mutex/unique_lock.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -22,8 +22,6 @@
# pragma GCC system_header
#endif

#ifndef _LIBCPP_HAS_NO_THREADS

_LIBCPP_BEGIN_NAMESPACE_STD

template <class _Mutex>
Expand Down Expand Up @@ -172,6 +170,4 @@ inline _LIBCPP_HIDE_FROM_ABI void swap(unique_lock<_Mutex>& __x, unique_lock<_Mu

_LIBCPP_END_NAMESPACE_STD

#endif // _LIBCPP_HAS_NO_THREADS

#endif // _LIBCPP___MUTEX_UNIQUE_LOCK_H
6 changes: 3 additions & 3 deletions libcxx/test/std/thread/thread.mutex/thread.lock/thread.lock.unique/implicit_ctad.pass.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -6,7 +6,6 @@
//
//===----------------------------------------------------------------------===//

// UNSUPPORTED: no-threads
// UNSUPPORTED: c++03, c++11, c++14

// <mutex>
Expand All @@ -18,12 +17,13 @@
#include <mutex>

#include "test_macros.h"
#include "types.h"

int main(int, char**) {
std::mutex mutex;
MyMutex mutex;
{
std::unique_lock lock(mutex);
ASSERT_SAME_TYPE(decltype(lock), std::unique_lock<std::mutex>);
ASSERT_SAME_TYPE(decltype(lock), std::unique_lock<MyMutex>);
}

return 0;
Expand Down
19 changes: 2 additions & 17 deletions ....unique.cons/copy_assign.compile.fail.cpp → ....unique.cons/copy_assign.compile.pass.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -13,22 +13,7 @@
// unique_lock& operator=(unique_lock const&) = delete;

#include <mutex>
#include <cassert>

int main(int, char**)
{
{
typedef std::mutex M;
M m0;
M m1;
std::unique_lock<M> lk0(m0);
std::unique_lock<M> lk1(m1);
lk1 = lk0;
assert(lk1.mutex() == &m0);
assert(lk1.owns_lock() == true);
assert(lk0.mutex() == nullptr);
assert(lk0.owns_lock() == false);
}
#include "../types.h"

return 0;
}
static_assert(!std::is_copy_assignable<std::lock_guard<MyMutex> >::value, "");
17 changes: 2 additions & 15 deletions ...ck.unique.cons/copy_ctor.compile.fail.cpp → ...ck.unique.cons/copy_ctor.compile.pass.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -13,20 +13,7 @@
// unique_lock(unique_lock const&) = delete;

#include <mutex>
#include <cassert>

int main(int, char**)
{
{
typedef std::mutex M;
M m;
std::unique_lock<M> lk0(m);
std::unique_lock<M> lk = lk0;
assert(lk.mutex() == &m);
assert(lk.owns_lock() == true);
assert(lk0.mutex() == nullptr);
assert(lk0.owns_lock() == false);
}
#include "../types.h"

return 0;
}
static_assert(!std::is_copy_constructible<std::lock_guard<MyMutex> >::value, "");
14 changes: 6 additions & 8 deletions ...read/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/default.pass.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -5,25 +5,23 @@
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
// UNSUPPORTED: no-threads

// <mutex>

// template <class Mutex> class unique_lock;

// unique_lock();

#include <mutex>
#include <cassert>
#include <mutex>

#include "test_macros.h"
#include "../types.h"

int main(int, char**)
{
std::unique_lock<std::mutex> ul;
assert(!ul.owns_lock());
assert(ul.mutex() == nullptr);
int main(int, char**) {
std::unique_lock<MyMutex> ul;
assert(!ul.owns_lock());
assert(ul.mutex() == nullptr);

return 0;
}
20 changes: 9 additions & 11 deletions .../thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/move_assign.pass.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -5,25 +5,23 @@
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
// UNSUPPORTED: no-threads, c++03

// <mutex>

// template <class Mutex> class unique_lock;

// unique_lock& operator=(unique_lock&& u);

#include <mutex>
#include <cassert>
#include "nasty_containers.h"
#include <mutex>

#include "nasty_containers.h"
#include "../types.h"
#include "test_macros.h"

int main(int, char**)
{
{
typedef std::mutex M;
int main(int, char**) {
{
typedef MyMutex M;
M m0;
M m1;
std::unique_lock<M> lk0(m0);
Expand All @@ -33,8 +31,8 @@ int main(int, char**)
assert(lk1.owns_lock() == true);
assert(lk0.mutex() == nullptr);
assert(lk0.owns_lock() == false);
}
{
}
{
typedef nasty_mutex M;
M m0;
M m1;
Expand All @@ -45,7 +43,7 @@ int main(int, char**)
assert(lk1.owns_lock() == true);
assert(lk0.mutex() == nullptr);
assert(lk0.owns_lock() == false);
}
}

return 0;
}
20 changes: 10 additions & 10 deletions ...ad/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/move_ctor.pass.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -6,33 +6,33 @@
//
//===----------------------------------------------------------------------===//
//
// UNSUPPORTED: no-threads, c++03
Copy link
Member

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

I'm not certain why this was disabled in C++03 mode. Either way, if it works in C++03 mode we might as well test it.

Copy link
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Oh, jeez. I missed that it was more than no-threads in this case. I'm happy to go either way, though.

// UNSUPPORTED: c++03

// <mutex>

// template <class Mutex> class unique_lock;

// unique_lock(unique_lock&& u);

#include <mutex>
#include <cassert>
#include "nasty_containers.h"
#include <mutex>

#include "nasty_containers.h"
#include "../types.h"
#include "test_macros.h"

int main(int, char**)
{
{
typedef std::mutex M;
int main(int, char**) {
{
typedef MyMutex M;
M m;
std::unique_lock<M> lk0(m);
std::unique_lock<M> lk = std::move(lk0);
assert(lk.mutex() == std::addressof(m));
assert(lk.owns_lock() == true);
assert(lk0.mutex() == nullptr);
assert(lk0.owns_lock() == false);
}
{
}
{
typedef nasty_mutex M;
M m;
std::unique_lock<M> lk0(m);
Expand All @@ -41,7 +41,7 @@ int main(int, char**)
assert(lk.owns_lock() == true);
assert(lk0.mutex() == nullptr);
assert(lk0.owns_lock() == false);
}
}

return 0;
}
19 changes: 9 additions & 10 deletions ...ad.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/mutex_adopt_lock.pass.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -6,7 +6,6 @@
//
//===----------------------------------------------------------------------===//
//
// UNSUPPORTED: no-threads
// UNSUPPORTED: c++03

// <mutex>
Expand All @@ -15,30 +14,30 @@

// unique_lock(mutex_type& m, adopt_lock_t);

#include <mutex>
#include <cassert>
#include "nasty_containers.h"
#include <mutex>

#include "nasty_containers.h"
#include "../types.h"
#include "test_macros.h"

int main(int, char**)
{
{
typedef std::mutex M;
int main(int, char**) {
{
typedef MyMutex M;
M m;
m.lock();
std::unique_lock<M> lk(m, std::adopt_lock);
assert(lk.mutex() == std::addressof(m));
assert(lk.owns_lock() == true);
}
{
}
{
typedef nasty_mutex M;
M m;
m.lock();
std::unique_lock<M> lk(m, std::adopt_lock);
assert(lk.mutex() == std::addressof(m));
assert(lk.owns_lock() == true);
}
}

return 0;
}
19 changes: 9 additions & 10 deletions ...ad.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/mutex_defer_lock.pass.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -6,7 +6,6 @@
//
//===----------------------------------------------------------------------===//
//
// UNSUPPORTED: no-threads
// UNSUPPORTED: c++03

// <mutex>
Expand All @@ -15,28 +14,28 @@

// unique_lock(mutex_type& m, defer_lock_t);

#include <mutex>
#include <cassert>
#include "nasty_containers.h"
#include <mutex>

#include "nasty_containers.h"
#include "../types.h"
#include "test_macros.h"

int main(int, char**)
{
{
typedef std::mutex M;
int main(int, char**) {
{
typedef MyMutex M;
M m;
std::unique_lock<M> lk(m, std::defer_lock);
assert(lk.mutex() == std::addressof(m));
assert(lk.owns_lock() == false);
}
{
}
{
typedef nasty_mutex M;
M m;
std::unique_lock<M> lk(m, std::defer_lock);
assert(lk.mutex() == std::addressof(m));
assert(lk.owns_lock() == false);
}
}

return 0;
}
4 changes: 2 additions & 2 deletions ...read/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.locking/lock.pass.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -51,7 +51,7 @@ void f()
}
catch (std::system_error& e)
{
assert(e.code().value() == EDEADLK);
assert(e.code() == std::errc::resource_deadlock_would_occur);
}
#endif
lk.unlock();
Expand All @@ -64,7 +64,7 @@ void f()
}
catch (std::system_error& e)
{
assert(e.code().value() == EPERM);
assert(e.code() == std::errc::operation_not_permitted);
}
#endif
}
Expand Down
Loading
Loading