[libcxx-commits] [libcxx] [libc++] Fix semaphore timed wait hanging on Windows (PR #180398)
via libcxx-commits
libcxx-commits at lists.llvm.org
Sun Feb 8 01:25:24 PST 2026
llvmbot wrote:
<!--LLVM PR SUMMARY COMMENT-->
@llvm/pr-subscribers-libcxx
Author: Hui (huixie90)
<details>
<summary>Changes</summary>
Fixes #<!-- -->180334
---
Full diff: https://github.com/llvm/llvm-project/pull/180398.diff
3 Files Affected:
- (modified) libcxx/src/atomic.cpp (+21-19)
- (added) libcxx/test/std/thread/thread.semaphore/timed.hang.pass.cpp (+45)
- (modified) libcxx/test/std/thread/thread.semaphore/timed.pass.cpp (+1-2)
``````````diff
diff --git a/libcxx/src/atomic.cpp b/libcxx/src/atomic.cpp
index 637c971ed8896..4d05815c76929 100644
--- a/libcxx/src/atomic.cpp
+++ b/libcxx/src/atomic.cpp
@@ -14,6 +14,7 @@
#include <cstring>
#include <functional>
#include <new>
+#include <optional>
#include <thread>
#include <type_traits>
@@ -64,17 +65,17 @@ _LIBCPP_BEGIN_NAMESPACE_STD
#ifdef __linux__
template <std::size_t _Size>
-static void __platform_wait_on_address(void const* __ptr, void const* __val, uint64_t __timeout_ns) {
+static void __platform_wait_on_address(void const* __ptr, void const* __val, optional<uint64_t> __timeout_ns) {
static_assert(_Size == 4, "Can only wait on 4 bytes value");
char buffer[_Size];
std::memcpy(&buffer, const_cast<const void*>(__val), _Size);
static constexpr timespec __default_timeout = {2, 0};
timespec __timeout;
- if (__timeout_ns == 0) {
+ if (!__timeout_ns.has_value()) {
__timeout = __default_timeout;
} else {
- __timeout.tv_sec = __timeout_ns / 1'000'000'000;
- __timeout.tv_nsec = __timeout_ns % 1'000'000'000;
+ __timeout.tv_sec = *__timeout_ns / 1'000'000'000;
+ __timeout.tv_nsec = *__timeout_ns % 1'000'000'000;
}
_LIBCPP_FUTEX(__ptr, FUTEX_WAIT_PRIVATE, *reinterpret_cast<__cxx_contention_t const*>(&buffer), &__timeout, 0, 0);
}
@@ -97,11 +98,12 @@ extern "C" int __ulock_wake(uint32_t operation, void* addr, uint64_t wake_value)
# define ULF_WAKE_ALL 0x00000100
template <std::size_t _Size>
-static void __platform_wait_on_address(void const* __ptr, void const* __val, uint64_t __timeout_ns) {
+static void __platform_wait_on_address(void const* __ptr, void const* __val, optional<uint64_t> __timeout_ns) {
static_assert(_Size == 8 || _Size == 4, "Can only wait on 8 bytes or 4 bytes value");
char buffer[_Size];
std::memcpy(&buffer, const_cast<const void*>(__val), _Size);
- auto __timeout_us = __timeout_ns == 0 ? 0 : static_cast<uint32_t>(__timeout_ns / 1000);
+ auto __timeout_us =
+ !__timeout_ns.has_value() ? uint32_t(0) : std::max(static_cast<uint32_t>(*__timeout_ns / 1000), uint32_t(1));
if constexpr (_Size == 4)
__ulock_wait(
UL_COMPARE_AND_WAIT, const_cast<void*>(__ptr), *reinterpret_cast<uint32_t const*>(&buffer), __timeout_us);
@@ -128,16 +130,16 @@ static void __platform_wake_by_address(void const* __ptr, bool __notify_one) {
*/
template <std::size_t _Size>
-static void __platform_wait_on_address(void const* __ptr, void const* __val, uint64_t __timeout_ns) {
+static void __platform_wait_on_address(void const* __ptr, void const* __val, optional<uint64_t> __timeout_ns) {
static_assert(_Size == 8, "Can only wait on 8 bytes value");
char buffer[_Size];
std::memcpy(&buffer, const_cast<const void*>(__val), _Size);
- if (__timeout_ns == 0) {
+ if (!__timeout_ns.has_value()) {
_umtx_op(const_cast<void*>(__ptr), UMTX_OP_WAIT, *reinterpret_cast<__cxx_contention_t*>(&buffer), nullptr, nullptr);
} else {
_umtx_time ut;
- ut._timeout.tv_sec = __timeout_ns / 1'000'000'000;
- ut._timeout.tv_nsec = __timeout_ns % 1'000'000'000;
+ ut._timeout.tv_sec = *__timeout_ns / 1'000'000'000;
+ ut._timeout.tv_nsec = *__timeout_ns % 1'000'000'000;
ut._flags = 0; // Relative time (not absolute)
ut._clockid = CLOCK_MONOTONIC; // Use monotonic clock
@@ -182,7 +184,7 @@ static void* win32_get_synch_api_function(const char* function_name) {
}
template <std::size_t _Size>
-static void __platform_wait_on_address(void const* __ptr, void const* __val, uint64_t __timeout_ns) {
+static void __platform_wait_on_address(void const* __ptr, void const* __val, optional<uint64_t> __timeout_ns) {
static_assert(_Size == 8, "Can only wait on 8 bytes value");
// WaitOnAddress was added in Windows 8 (build 9200)
static auto wait_on_address =
@@ -191,12 +193,12 @@ static void __platform_wait_on_address(void const* __ptr, void const* __val, uin
wait_on_address(const_cast<void*>(__ptr),
const_cast<void*>(__val),
_Size,
- __timeout_ns == 0 ? INFINITE : static_cast<DWORD>(__timeout_ns / 1'000'000));
+ !__timeout_ns.has_value() ? INFINITE : static_cast<DWORD>(*__timeout_ns / 1'000'000));
} else {
__libcpp_thread_poll_with_backoff(
[=]() -> bool { return std::memcmp(const_cast<const void*>(__ptr), __val, _Size) != 0; },
__libcpp_timed_backoff_policy(),
- std::chrono::nanoseconds(__timeout_ns));
+ std::chrono::nanoseconds(__timeout_ns.value_or(0)));
}
}
@@ -231,7 +233,7 @@ static void __platform_wake_by_address(void const* __ptr, bool __notify_one) {
// Baseline is just a timed backoff
template <std::size_t _Size>
-static void __platform_wait_on_address(void const* __ptr, void const* __val, uint64_t __timeout_ns) {
+static void __platform_wait_on_address(void const* __ptr, void const* __val, optional<uint64_t> __timeout_ns) {
__libcpp_thread_poll_with_backoff(
[=]() -> bool { return std::memcmp(const_cast<const void*>(__ptr), __val, _Size) != 0; },
__libcpp_timed_backoff_policy(),
@@ -262,7 +264,7 @@ template <std::size_t _Size>
static void __contention_wait(__cxx_atomic_contention_t* __waiter_count,
void const* __address_to_wait,
void const* __old_value,
- uint64_t __timeout_ns) {
+ optional<uint64_t> __timeout_ns) {
__cxx_atomic_fetch_add(__waiter_count, __cxx_contention_t(1), memory_order_relaxed);
// https://llvm.org/PR109290
// There are no platform guarantees of a memory barrier in the platform wait implementation
@@ -331,7 +333,7 @@ _LIBCPP_EXPORTED_FROM_ABI void
__atomic_wait_global_table(void const* __location, __cxx_contention_t __old_value) noexcept {
auto const __entry = __get_global_contention_state(__location);
__contention_wait<sizeof(__cxx_atomic_contention_t)>(
- &__entry->__waiter_count, &__entry->__platform_state, &__old_value, 0);
+ &__entry->__waiter_count, &__entry->__platform_state, &__old_value, nullopt);
}
_LIBCPP_EXPORTED_FROM_ABI void __atomic_wait_global_table_with_timeout(
@@ -353,7 +355,7 @@ _LIBCPP_EXPORTED_FROM_ABI void __atomic_notify_all_global_table(void const* __lo
template <std::size_t _Size>
_LIBCPP_EXPORTED_FROM_ABI void __atomic_wait_native(void const* __address, void const* __old_value) noexcept {
- __contention_wait<_Size>(__get_native_waiter_count(__address), __address, __old_value, 0);
+ __contention_wait<_Size>(__get_native_waiter_count(__address), __address, __old_value, nullopt);
}
template <std::size_t _Size>
@@ -428,7 +430,7 @@ _LIBCPP_EXPORTED_FROM_ABI void
__libcpp_atomic_wait(void const volatile* __location, __cxx_contention_t __old_value) noexcept {
auto const __entry = __get_global_contention_state(const_cast<void const*>(__location));
__contention_wait<sizeof(__cxx_atomic_contention_t)>(
- &__entry->__waiter_count, &__entry->__platform_state, &__old_value, 0);
+ &__entry->__waiter_count, &__entry->__platform_state, &__old_value, nullopt);
}
_LIBCPP_EXPORTED_FROM_ABI void __cxx_atomic_notify_one(__cxx_atomic_contention_t const volatile* __location) noexcept {
@@ -447,7 +449,7 @@ _LIBCPP_EXPORTED_FROM_ABI void
__libcpp_atomic_wait(__cxx_atomic_contention_t const volatile* __location, __cxx_contention_t __old_value) noexcept {
auto __location_cast = const_cast<const void*>(static_cast<const volatile void*>(__location));
__contention_wait<sizeof(__cxx_atomic_contention_t)>(
- __get_native_waiter_count(__location_cast), __location_cast, &__old_value, 0);
+ __get_native_waiter_count(__location_cast), __location_cast, &__old_value, nullopt);
}
// this function is even unused in the old ABI
diff --git a/libcxx/test/std/thread/thread.semaphore/timed.hang.pass.cpp b/libcxx/test/std/thread/thread.semaphore/timed.hang.pass.cpp
new file mode 100644
index 0000000000000..75366bd4f5397
--- /dev/null
+++ b/libcxx/test/std/thread/thread.semaphore/timed.hang.pass.cpp
@@ -0,0 +1,45 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// UNSUPPORTED: no-threads
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+
+// <semaphore>
+
+// This is a regression test for a bug in semaphore::try_acquire_for
+// where it can wait indefinitely
+// https://github.com/llvm/llvm-project/issues/180334
+
+#include <semaphore>
+#include <thread>
+#include <chrono>
+#include <cassert>
+
+#include "make_test_thread.h"
+#include "test_macros.h"
+
+void test() {
+ auto const start = std::chrono::steady_clock::now();
+ std::counting_semaphore<> s(0);
+
+ assert(!s.try_acquire_for(std::chrono::nanoseconds(1)));
+ assert(!s.try_acquire_for(std::chrono::microseconds(1)));
+ assert(!s.try_acquire_for(std::chrono::milliseconds(1)));
+ assert(!s.try_acquire_for(std::chrono::milliseconds(100)));
+
+ auto const end = std::chrono::steady_clock::now();
+ assert(end - start < std::chrono::seconds(10));
+}
+
+int main(int, char**) {
+ for (auto i = 0; i < 10; ++i) {
+ test();
+ }
+
+ return 0;
+}
diff --git a/libcxx/test/std/thread/thread.semaphore/timed.pass.cpp b/libcxx/test/std/thread/thread.semaphore/timed.pass.cpp
index d0aa1f46072b9..5b3aac6718075 100644
--- a/libcxx/test/std/thread/thread.semaphore/timed.pass.cpp
+++ b/libcxx/test/std/thread/thread.semaphore/timed.pass.cpp
@@ -19,8 +19,7 @@
#include "make_test_thread.h"
#include "test_macros.h"
-int main(int, char**)
-{
+int main(int, char**) {
auto const start = std::chrono::steady_clock::now();
std::counting_semaphore<> s(0);
``````````
</details>
https://github.com/llvm/llvm-project/pull/180398
More information about the libcxx-commits
mailing list