Patch Detail
get:
Show a patch.
patch:
Update a patch.
put:
Update a patch.
GET /api/1.2/patches/2226302/?format=api
{ "id": 2226302, "url": "http://patchwork.ozlabs.org/api/1.2/patches/2226302/?format=api", "web_url": "http://patchwork.ozlabs.org/project/gcc/patch/bmm.hhubrmqub2.gcc.gcc-TEST.redi.31.1.4@forge-stage.sourceware.org/", "project": { "id": 17, "url": "http://patchwork.ozlabs.org/api/1.2/projects/17/?format=api", "name": "GNU Compiler Collection", "link_name": "gcc", "list_id": "gcc-patches.gcc.gnu.org", "list_email": "gcc-patches@gcc.gnu.org", "web_url": null, "scm_url": null, "webscm_url": null, "list_archive_url": "", "list_archive_url_format": "", "commit_url_format": "" }, "msgid": "<bmm.hhubrmqub2.gcc.gcc-TEST.redi.31.1.4@forge-stage.sourceware.org>", "list_archive_url": null, "date": "2026-04-22T10:44:19", "name": "[v1,04/16] libstdc++: Various fixes for atomic wait/notify code", "commit_ref": null, "pull_url": null, "state": "new", "archived": false, "hash": "93c7b00ec37cf5a6b88e842605d35d17530e40b3", "submitter": { "id": 93210, "url": "http://patchwork.ozlabs.org/api/1.2/people/93210/?format=api", "name": "Jonathan Wakely via Sourceware Forge", "email": "forge-bot+redi@forge-stage.sourceware.org" }, "delegate": null, "mbox": "http://patchwork.ozlabs.org/project/gcc/patch/bmm.hhubrmqub2.gcc.gcc-TEST.redi.31.1.4@forge-stage.sourceware.org/mbox/", "series": [ { "id": 500987, "url": "http://patchwork.ozlabs.org/api/1.2/series/500987/?format=api", "web_url": "http://patchwork.ozlabs.org/project/gcc/list/?series=500987", "date": "2026-04-22T10:44:17", "name": "atomic wait/notify ABI stabilization", "version": 1, "mbox": "http://patchwork.ozlabs.org/series/500987/mbox/" } ], "comments": "http://patchwork.ozlabs.org/api/patches/2226302/comments/", "check": "pending", "checks": "http://patchwork.ozlabs.org/api/patches/2226302/checks/", "tags": {}, "related": [], "headers": { "Return-Path": "<gcc-patches-bounces~incoming=patchwork.ozlabs.org@gcc.gnu.org>", "X-Original-To": [ "incoming@patchwork.ozlabs.org", "gcc-patches@gcc.gnu.org" ], "Delivered-To": [ "patchwork-incoming@legolas.ozlabs.org", "gcc-patches@gcc.gnu.org" ], "Authentication-Results": [ "legolas.ozlabs.org;\n spf=pass (sender SPF authorized) smtp.mailfrom=gcc.gnu.org\n (client-ip=38.145.34.32; helo=vm01.sourceware.org;\n envelope-from=gcc-patches-bounces~incoming=patchwork.ozlabs.org@gcc.gnu.org;\n receiver=patchwork.ozlabs.org)", "sourceware.org; dmarc=none (p=none dis=none)\n header.from=forge-stage.sourceware.org", "sourceware.org;\n spf=pass smtp.mailfrom=forge-stage.sourceware.org", "server2.sourceware.org;\n arc=none smtp.remote-ip=38.145.34.39" ], "Received": [ "from vm01.sourceware.org (vm01.sourceware.org [38.145.34.32])\n\t(using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits)\n\t key-exchange x25519 server-signature ECDSA (secp384r1) server-digest SHA384)\n\t(No client certificate requested)\n\tby legolas.ozlabs.org (Postfix) with ESMTPS id 4g0xdp37vWz1yD5\n\tfor <incoming@patchwork.ozlabs.org>; Wed, 22 Apr 2026 21:22:22 +1000 (AEST)", "from vm01.sourceware.org (localhost [127.0.0.1])\n\tby sourceware.org (Postfix) with ESMTP id 681C14405076\n\tfor <incoming@patchwork.ozlabs.org>; Wed, 22 Apr 2026 11:22:20 +0000 (GMT)", "from forge-stage.sourceware.org (vm08.sourceware.org [38.145.34.39])\n by sourceware.org (Postfix) with ESMTPS id D7DA64015E94\n for <gcc-patches@gcc.gnu.org>; Wed, 22 Apr 2026 10:46:01 +0000 (GMT)", "from forge-stage.sourceware.org (localhost [IPv6:::1])\n (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits)\n key-exchange x25519 server-signature ECDSA (prime256v1) server-digest SHA256)\n (No client certificate requested)\n by forge-stage.sourceware.org (Postfix) with ESMTPS id ACABF42BB2\n for <gcc-patches@gcc.gnu.org>; Wed, 22 Apr 2026 10:46:01 +0000 (UTC)" ], "DKIM-Filter": [ "OpenDKIM Filter v2.11.0 sourceware.org 681C14405076", "OpenDKIM Filter v2.11.0 sourceware.org D7DA64015E94" ], "DMARC-Filter": "OpenDMARC Filter v1.4.2 sourceware.org D7DA64015E94", "ARC-Filter": "OpenARC Filter v1.0.0 sourceware.org D7DA64015E94", "ARC-Seal": "i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1776854761; cv=none;\n b=tuyLYeVTuWDdUcEsp18zJyNG2yajpxat4z+yObCt7W+vtYCCfqfgYNDGQqYUwuELcOl/kPqnyEos3vNdvLtsMV0vbvUGXvkQuEmeEFIaUv9aOep8/T6/UAF34Kw/SCLg+BWA3BdoNj5kDAbeVj1KwoGYyxgx63AUUB9FJAE7Dq8=", "ARC-Message-Signature": "i=1; a=rsa-sha256; d=sourceware.org; s=key;\n t=1776854761; c=relaxed/simple;\n bh=ktM+Aq6HVIf0fCgCejmoZJZFdi+kjPOWDXmYdJtpcmY=;\n h=From:Date:Subject:To:Message-ID;\n b=LZRIODpEOt3lYqNWqYXWUZfzZSxD4UvYIO352LHNcXF9tY9pTWRXuBTKJyqCWeQBiPBdHBGD65qs9UJvIVFY3ProAgX66Vy8NAVw3TOBXtNraUoFtYwKZ3U+43B+jig7AWaGeMBlftsSjWGtg1JyECvuRrF7VcLxZyilq7d1zuI=", "ARC-Authentication-Results": "i=1; server2.sourceware.org", "From": "Jonathan Wakely via Sourceware Forge\n <forge-bot+redi@forge-stage.sourceware.org>", "Date": "Wed, 22 Apr 2026 10:44:19 +0000", "Subject": "[PATCH v1 04/16] libstdc++: Various fixes for atomic wait/notify code", "To": "gcc-patches mailing list <gcc-patches@gcc.gnu.org>", "Message-ID": "\n <bmm.hhubrmqub2.gcc.gcc-TEST.redi.31.1.4@forge-stage.sourceware.org>", "X-Mailer": "batrachomyomachia", "X-Pull-Request-Organization": "gcc", "X-Pull-Request-Repository": "gcc-TEST", "X-Pull-Request": "https://forge.sourceware.org/gcc/gcc-TEST/pulls/31", "References": "\n <bmm.hhubrmqub2.gcc.gcc-TEST.redi.31.1.0@forge-stage.sourceware.org>", "In-Reply-To": "\n <bmm.hhubrmqub2.gcc.gcc-TEST.redi.31.1.0@forge-stage.sourceware.org>", "X-Patch-URL": "\n https://forge.sourceware.org/redi/gcc/commit/93ff0912fafc9d8d8c8554615cffef3f362aa136", "X-BeenThere": "gcc-patches@gcc.gnu.org", "X-Mailman-Version": "2.1.30", "Precedence": "list", "List-Id": "Gcc-patches mailing list <gcc-patches.gcc.gnu.org>", "List-Unsubscribe": "<https://gcc.gnu.org/mailman/options/gcc-patches>,\n <mailto:gcc-patches-request@gcc.gnu.org?subject=unsubscribe>", "List-Archive": "<https://gcc.gnu.org/pipermail/gcc-patches/>", "List-Post": "<mailto:gcc-patches@gcc.gnu.org>", "List-Help": "<mailto:gcc-patches-request@gcc.gnu.org?subject=help>", "List-Subscribe": "<https://gcc.gnu.org/mailman/listinfo/gcc-patches>,\n <mailto:gcc-patches-request@gcc.gnu.org?subject=subscribe>", "Reply-To": "gcc-patches mailing list <gcc-patches@gcc.gnu.org>, redi@gcc.gnu.org", "Errors-To": "gcc-patches-bounces~incoming=patchwork.ozlabs.org@gcc.gnu.org" }, "content": "From: Jonathan Wakely <jwakely@redhat.com>\n\nPass __wait_args_base by const reference instead of const pointer. I\ndon't see a reason it needs to be passed by pointer to the internals.\nWe can also avoid constructing a __wait_args from __wait_args_base in\nsome places, instaad just using the latter directly.\n\nThe code using the __wait_flags bitmask type is broken, because the\n__spin_only constant includes the __do_spin element. This means that\ntesting (__args & __wait_flags::__spin_only) will be inadvertently true\nwhen only __do_spin is set. This causes the __wait_until_impl function\nto never actually wait on the futex (or condition variable), turning all\nuses of that function into expensive busy spins. Change __spin_only to\nbe a single bit (i.e. a bitmask element) and adjust the places where\nthat bit is set so that they also use the __do_spin element.\n\nUpdate the __args._M_old value when looping in __atomic_wait_address, so\nthat the next wait doesn't fail spuriously.\n\nWith the new __atomic_wait_address logic, the value function needs to\nreturn the correct type, not just a bool. Without that change, the\nboolean value returned by the value function is used as the value\npassed to the futex wait, but that mean we're comparing (_M_a == 0) to\n_M_a and so can block on the futex when we shouldn't, and then never\nwake up.\n\nlibstdc++-v3/ChangeLog:\n\n\t* include/bits/atomic_timed_wait.h (__cond_wait_impl): Add\n\tmissing inline keyword.\n\t(__spin_until_impl): Change parameter from pointer to reference.\n\tReplace make_pair with list-initialization. Initialize variable\n\tfor return value.\n\t(__wait_until_impl): Likewise. Remove some preprocessor\n\tconditional logic. Use _S_track for contention tracking.\n\tAvoid unnecessary const_cast.\n\t(__wait_until): Change parameter from pointer to reference.\n\tReplace make_pair with list-initialization.\n\t(__wait_for): Change parameter from pointer to reference. Add\n\t__do_spin flag to args.\n\t* include/bits/atomic_wait.h (__waiter_pool_impl::_S_track): New\n\tfunction returning an RAII object for contention tracking.\n\t(__wait_flags): Do not set the __do_spin flag in the __spin_only\n\tenumerator. Comment out the unused __abi_version_mask\n\tenumerator. Define operator| and operator|= overloads.\n\t(__wait_args_base::operator&): Define.\n\t(__wait_args::operator&, __wait_args::_S_default_flags): Remove.\n\t(__wait_args::operator|, __wait_args::operator|=): Remove.\n\t(__spin_impl): Change parameter from pointer to reference.\n\tReplace make_pair call with list-initialization.\n\t(__wait_impl): Likewise. Remove some preprocessor conditional\n\tlogic. Always store old value in __args._M_old. Avoid\n\tunnecessary const_cast. Use _S_track.\n\t(__notify_impl): Change parameter to reference. Remove some\n\tpreprocessor conditional logic.\n\t(__atomic_wait_address): Add comment. Update __args._M_old on\n\teach iteration.\n\t(__atomic_wait_address_v): Add comment.\n\t* include/std/latch (latch::wait): Adjust predicates for new\n\tlogic.\n\t* testsuite/29_atomics/atomic_integral/wait_notify.cc: Improve\n\ttest.\n---\n libstdc++-v3/include/bits/atomic_timed_wait.h | 98 +++----\n libstdc++-v3/include/bits/atomic_wait.h | 263 ++++++++++--------\n libstdc++-v3/include/std/latch | 8 +-\n .../29_atomics/atomic_integral/wait_notify.cc | 8 +-\n 4 files changed, 189 insertions(+), 188 deletions(-)", "diff": "diff --git a/libstdc++-v3/include/bits/atomic_timed_wait.h b/libstdc++-v3/include/bits/atomic_timed_wait.h\nindex e5a5f283bca0..9fc28f3d2696 100644\n--- a/libstdc++-v3/include/bits/atomic_timed_wait.h\n+++ b/libstdc++-v3/include/bits/atomic_timed_wait.h\n@@ -104,14 +104,14 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION\n return true;\n }\n #else\n-// define _GLIBCXX_HAVE_PLATFORM_TIMED_WAIT and implement __platform_wait_until()\n+// define _GLIBCXX_HAVE_PLATFORM_TIMED_WAIT and implement __platform_wait_until\n // if there is a more efficient primitive supported by the platform\n-// (e.g. __ulock_wait())which is better than pthread_cond_clockwait\n-#endif // ! PLATFORM_TIMED_WAIT\n+// (e.g. __ulock_wait) which is better than pthread_cond_clockwait.\n+#endif // ! HAVE_LINUX_FUTEX\n \n #ifdef _GLIBCXX_HAS_GTHREADS\n // Returns true if wait ended before timeout.\n- bool\n+ inline bool\n __cond_wait_until(__condvar& __cv, mutex& __mx,\n \t\t const __wait_clock_t::time_point& __atime)\n {\n@@ -136,14 +136,13 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION\n \n inline __wait_result_type\n __spin_until_impl(const __platform_wait_t* __addr,\n-\t\t const __wait_args_base* __a,\n+\t\t const __wait_args_base& __args,\n \t\t const __wait_clock_t::time_point& __deadline)\n {\n- __wait_args __args{ *__a };\n auto __t0 = __wait_clock_t::now();\n using namespace literals::chrono_literals;\n \n- __platform_wait_t __val;\n+ __platform_wait_t __val{};\n auto __now = __wait_clock_t::now();\n for (; __now < __deadline; __now = __wait_clock_t::now())\n \t{\n@@ -157,94 +156,70 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION\n #endif\n \t if (__elapsed > 4us)\n \t __thread_yield();\n-\t else\n-\t {\n-\t auto __res = __detail::__spin_impl(__addr, __a);\n-\t if (__res.first)\n-\t\treturn __res;\n-\t }\n+\t else if (auto __res = __detail::__spin_impl(__addr, __args); __res.first)\n+\t return __res;\n \n \t __atomic_load(__addr, &__val, __args._M_order);\n \t if (__val != __args._M_old)\n-\t return make_pair(true, __val);\n+\t return { true, __val };\n \t}\n- return make_pair(false, __val);\n+ return { false, __val };\n }\n \n inline __wait_result_type\n __wait_until_impl(const __platform_wait_t* __addr,\n-\t\t const __wait_args_base* __a,\n+\t\t const __wait_args_base& __a,\n \t\t const __wait_clock_t::time_point& __atime)\n {\n- __wait_args __args{ *__a };\n-#ifdef _GLIBCXX_HAVE_PLATFORM_TIMED_WAIT\n+ __wait_args_base __args = __a;\n __waiter_pool_impl* __pool = nullptr;\n-#else\n- // if we don't have __platform_wait, we always need the side-table\n- __waiter_pool_impl* __pool = &__waiter_pool_impl::_S_impl_for(__addr);\n-#endif\n-\n- __platform_wait_t* __wait_addr;\n+ const __platform_wait_t* __wait_addr;\n if (__args & __wait_flags::__proxy_wait)\n \t{\n-#ifdef _GLIBCXX_HAVE_PLATFORM_TIMED_WAIT\n \t __pool = &__waiter_pool_impl::_S_impl_for(__addr);\n-#endif\n \t __wait_addr = &__pool->_M_ver;\n \t __atomic_load(__wait_addr, &__args._M_old, __args._M_order);\n \t}\n else\n-\t__wait_addr = const_cast<__platform_wait_t*>(__addr);\n+\t__wait_addr = __addr;\n \n if (__args & __wait_flags::__do_spin)\n \t{\n-\t auto __res = __detail::__spin_until_impl(__wait_addr, __a, __atime);\n+\t auto __res = __detail::__spin_until_impl(__wait_addr, __args, __atime);\n \t if (__res.first)\n \t return __res;\n \t if (__args & __wait_flags::__spin_only)\n \t return __res;\n \t}\n \n- if (!(__args & __wait_flags::__track_contention))\n-\t{\n-\t // caller does not externally track contention\n-#ifdef _GLIBCXX_HAVE_PLATFORM_TIMED_WAIT\n-\t __pool = (__pool == nullptr) ? &__waiter_pool_impl::_S_impl_for(__addr)\n-\t\t\t\t : __pool;\n-#endif\n-\t __pool->_M_enter_wait();\n-\t}\n+ auto __tracker = __waiter_pool_impl::_S_track(__pool, __args, __addr);\n \n- __wait_result_type __res;\n #ifdef _GLIBCXX_HAVE_PLATFORM_TIMED_WAIT\n if (__platform_wait_until(__wait_addr, __args._M_old, __atime))\n-\t__res = make_pair(true, __args._M_old);\n+\treturn { true, __args._M_old };\n else\n-\t__res = make_pair(false, __args._M_old);\n+\treturn { false, __args._M_old };\n #else\n- __platform_wait_t __val;\n+ __platform_wait_t __val{};\n __atomic_load(__wait_addr, &__val, __args._M_order);\n if (__val == __args._M_old)\n \t{\n+\t if (!__pool)\n+\t __pool = &__waiter_pool_impl::_S_impl_for(__addr);\n \t lock_guard<mutex> __l{ __pool->_M_mtx };\n \t __atomic_load(__wait_addr, &__val, __args._M_order);\n-\t if (__val == __args._M_old &&\n-\t __cond_wait_until(__pool->_M_cv, __pool->_M_mtx, __atime))\n-\t __res = make_pair(true, __val);\n+\t if (__val == __args._M_old\n+\t\t&& __cond_wait_until(__pool->_M_cv, __pool->_M_mtx, __atime))\n+\t return { true, __val };\n \t}\n- else\n-\t__res = make_pair(false, __val);\n+ return { false, __val };\n #endif\n-\n- if (!(__args & __wait_flags::__track_contention))\n-\t// caller does not externally track contention\n-\t__pool->_M_leave_wait();\n- return __res;\n }\n \n+ // Returns {true, val} if wait ended before a timeout.\n template<typename _Clock, typename _Dur>\n __wait_result_type\n- __wait_until(const __platform_wait_t* __addr, const __wait_args* __args,\n+ __wait_until(const __platform_wait_t* __addr, const __wait_args_base& __args,\n \t\t const chrono::time_point<_Clock, _Dur>& __atime) noexcept\n {\n \tif constexpr (is_same_v<__wait_clock_t, _Clock>)\n@@ -259,28 +234,29 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION\n \t\t// we need to check against the caller-supplied clock\n \t\t// to tell whether we should return a timeout.\n \t\tif (_Clock::now() < __atime)\n-\t\t return make_pair(true, __res.second);\n+\t\t __res.first = true;\n \t }\n \t return __res;\n \t }\n }\n \n+ // Returns {true, val} if wait ended before a timeout.\n template<typename _Rep, typename _Period>\n __wait_result_type\n- __wait_for(const __platform_wait_t* __addr, const __wait_args_base* __a,\n+ __wait_for(const __platform_wait_t* __addr, const __wait_args_base& __args,\n \t\t const chrono::duration<_Rep, _Period>& __rtime) noexcept\n {\n-\t__wait_args __args{ *__a };\n \tif (!__rtime.count())\n \t {\n+\t __wait_args_base __a = __args;\n \t // no rtime supplied, just spin a bit\n-\t __args |= __wait_flags::__spin_only;\n-\t return __detail::__wait_impl(__addr, &__args);\n+\t __a._M_flags |= __wait_flags::__do_spin | __wait_flags::__spin_only;\n+\t return __detail::__wait_impl(__addr, __a);\n \t }\n \n \tauto const __reltime = chrono::ceil<__wait_clock_t::duration>(__rtime);\n \tauto const __atime = chrono::steady_clock::now() + __reltime;\n-\treturn __detail::__wait_until(__addr, &__args, __atime);\n+\treturn __detail::__wait_until(__addr, __args, __atime);\n }\n } // namespace __detail\n \n@@ -300,7 +276,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION\n _Tp __val = __vfn();\n while (!__pred(__val))\n \t{\n-\t auto __res = __detail::__wait_until(__wait_addr, &__args, __atime);\n+\t auto __res = __detail::__wait_until(__wait_addr, __args, __atime);\n \t if (!__res.first)\n \t // timed out\n \t return __res.first; // C++26 will also return last observed __val\n@@ -350,7 +326,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION\n _Tp __val = __vfn();\n while (!__pred(__val))\n \t{\n-\t auto __res = __detail::__wait_for(__wait_addr, &__args, __rtime);\n+\t auto __res = __detail::__wait_for(__wait_addr, __args, __rtime);\n \t if (!__res.first)\n \t // timed out\n \t return __res.first; // C++26 will also return last observed __val\n@@ -368,7 +344,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION\n \t\t\t\tbool __bare_wait = false) noexcept\n {\n __detail::__wait_args __args{ __addr, __old, __order, __bare_wait };\n- auto __res = __detail::__wait_for(__addr, &__args, __rtime);\n+ auto __res = __detail::__wait_for(__addr, __args, __rtime);\n return __res.first; // C++26 will also return last observed __Val\n }\n \ndiff --git a/libstdc++-v3/include/bits/atomic_wait.h b/libstdc++-v3/include/bits/atomic_wait.h\nindex ebab4b099e66..172910a4e34f 100644\n--- a/libstdc++-v3/include/bits/atomic_wait.h\n+++ b/libstdc++-v3/include/bits/atomic_wait.h\n@@ -160,6 +160,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION\n \treturn __builtin_memcmp(&__a, &__b, sizeof(_Tp)) == 0;\n }\n \n+ struct __wait_args_base;\n+\n struct __waiter_pool_impl\n {\n // Don't use std::hardware_destructive_interference_size here because we\n@@ -177,6 +179,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION\n #ifndef _GLIBCXX_HAVE_PLATFORM_WAIT\n __condvar _M_cv;\n #endif\n+\n __waiter_pool_impl() = default;\n \n void\n@@ -203,6 +206,12 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION\n \tauto __key = ((__UINTPTR_TYPE__)__addr >> 2) % __ct;\n \treturn __w[__key];\n }\n+\n+ // Return an RAII type that calls _M_enter_wait() on construction\n+ // and _M_leave_wait() on destruction.\n+ static auto\n+ _S_track(__waiter_pool_impl*& __pool, const __wait_args_base& __args,\n+\t const void* __addr) noexcept;\n };\n \n enum class __wait_flags : __UINT_LEAST32_TYPE__\n@@ -211,88 +220,72 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION\n __proxy_wait = 1,\n __track_contention = 2,\n __do_spin = 4,\n- __spin_only = 8 | __do_spin, // implies __do_spin\n- __abi_version_mask = 0xffff0000,\n+ __spin_only = 8, // Ignored unless __do_spin is also set.\n+ // __abi_version_mask = 0xffff0000,\n };\n \n+ [[__gnu__::__always_inline__]]\n+ constexpr __wait_flags\n+ operator|(__wait_flags __l, __wait_flags __r) noexcept\n+ {\n+ using _Ut = underlying_type_t<__wait_flags>;\n+ return static_cast<__wait_flags>(static_cast<_Ut>(__l)\n+\t\t\t\t\t | static_cast<_Ut>(__r));\n+ }\n+\n+ [[__gnu__::__always_inline__]]\n+ constexpr __wait_flags&\n+ operator|=(__wait_flags& __l, __wait_flags __r) noexcept\n+ { return __l = __l | __r; }\n+\n+ // Simple aggregate containing arguments used by implementation details.\n struct __wait_args_base\n {\n __wait_flags _M_flags;\n int _M_order = __ATOMIC_ACQUIRE;\n __platform_wait_t _M_old = 0;\n+\n+ // Test whether _M_flags & __flags is non-zero.\n+ bool\n+ operator&(__wait_flags __flags) const noexcept\n+ {\n+\t using _Ut = underlying_type_t<__wait_flags>;\n+\t return static_cast<_Ut>(_M_flags) & static_cast<_Ut>(__flags);\n+ }\n };\n \n+ // Utility for populating a __wait_args_base structure.\n struct __wait_args : __wait_args_base\n {\n- template<typename _Tp>\n-\texplicit __wait_args(const _Tp* __addr,\n-\t\t\t bool __bare_wait = false) noexcept\n-\t : __wait_args_base{ _S_flags_for(__addr, __bare_wait) }\n+ template<typename _Tp> requires (!is_same_v<_Tp, __wait_args>)\n+\texplicit\n+\t__wait_args(const _Tp* __addr, bool __bare_wait = false) noexcept\n+\t: __wait_args_base{ _S_flags_for(__addr, __bare_wait) }\n \t{ }\n \n __wait_args(const __platform_wait_t* __addr, __platform_wait_t __old,\n \t\t int __order, bool __bare_wait = false) noexcept\n-\t : __wait_args_base{ _S_flags_for(__addr, __bare_wait), __order, __old }\n-\t{ }\n-\n- explicit __wait_args(const __wait_args_base& __base)\n-\t : __wait_args_base{ __base }\n-\t{ }\n+ : __wait_args_base{ _S_flags_for(__addr, __bare_wait), __order, __old }\n+ { }\n \n __wait_args(const __wait_args&) noexcept = default;\n- __wait_args&\n- operator=(const __wait_args&) noexcept = default;\n-\n- bool\n- operator&(__wait_flags __flag) const noexcept\n- {\n-\t using __t = underlying_type_t<__wait_flags>;\n-\t return static_cast<__t>(_M_flags)\n-\t & static_cast<__t>(__flag);\n- }\n-\n- __wait_args\n- operator|(__wait_flags __flag) const noexcept\n- {\n-\tusing __t = underlying_type_t<__wait_flags>;\n-\t__wait_args __res{ *this };\n-\tconst auto __flags = static_cast<__t>(__res._M_flags)\n-\t\t\t | static_cast<__t>(__flag);\n-\t__res._M_flags = __wait_flags{ __flags };\n-\treturn __res;\n- }\n-\n- __wait_args&\n- operator|=(__wait_flags __flag) noexcept\n- {\n-\tusing __t = underlying_type_t<__wait_flags>;\n-\tconst auto __flags = static_cast<__t>(_M_flags)\n-\t\t\t | static_cast<__t>(__flag);\n-\t_M_flags = __wait_flags{ __flags };\n-\treturn *this;\n- }\n+ __wait_args& operator=(const __wait_args&) noexcept = default;\n \n private:\n- static int\n- constexpr _S_default_flags() noexcept\n- {\n-\tusing __t = underlying_type_t<__wait_flags>;\n-\treturn static_cast<__t>(__wait_flags::__abi_version)\n-\t\t| static_cast<__t>(__wait_flags::__do_spin);\n- }\n-\n template<typename _Tp>\n-\tstatic __wait_flags\n-\tconstexpr _S_flags_for(const _Tp*, bool __bare_wait) noexcept\n+\tstatic constexpr __wait_flags\n+\t_S_flags_for(const _Tp*, bool __bare_wait) noexcept\n \t{\n-\t auto __res = _S_default_flags();\n+\t using enum __wait_flags;\n+\t __wait_flags __res = __abi_version | __do_spin;\n \t if (!__bare_wait)\n-\t __res |= static_cast<int>(__wait_flags::__track_contention);\n+\t __res |= __track_contention;\n \t if constexpr (!__platform_wait_uses_type<_Tp>)\n-\t __res |= static_cast<int>(__wait_flags::__proxy_wait);\n-\t return static_cast<__wait_flags>(__res);\n+\t __res |= __proxy_wait;\n+\t return __res;\n \t}\n \n+ // XXX what is this for? It's never used.\n template<typename _Tp>\n \tstatic int\n \t_S_memory_order_for(const _Tp*, int __order) noexcept\n@@ -303,141 +296,157 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION\n \t}\n };\n \n+ inline auto\n+ __waiter_pool_impl::_S_track(__waiter_pool_impl*& __pool,\n+\t\t\t\t const __wait_args_base& __args,\n+\t\t\t\t const void* __addr) noexcept\n+ {\n+ struct _Tracker\n+ {\n+\t_Tracker() noexcept : _M_st(nullptr) { }\n+\n+\t[[__gnu__::__nonnull__]]\n+\texplicit\n+\t_Tracker(__waiter_pool_impl* __st) noexcept\n+\t: _M_st(__st)\n+\t{ __st->_M_enter_wait(); }\n+\n+\t_Tracker(const _Tracker&) = delete;\n+\t_Tracker& operator=(const _Tracker&) = delete;\n+\n+\t~_Tracker() { if (_M_st) _M_st->_M_leave_wait(); }\n+\n+\t__waiter_pool_impl* _M_st;\n+ };\n+\n+ if (__args & __wait_flags::__track_contention)\n+\t{\n+\t // Caller does not externally track contention,\n+\t // so we want to increment+decrement __pool->_M_waiters\n+\n+\t // First make sure we have a waitable state for the address.\n+\t if (!__pool)\n+\t __pool = &__waiter_pool_impl::_S_impl_for(__addr);\n+\n+\t // This object will increment the number of waiters and\n+\t // decrement it again on destruction.\n+\t return _Tracker{__pool};\n+\t}\n+ return _Tracker{}; // For bare waits caller tracks waiters.\n+ }\n+\n using __wait_result_type = pair<bool, __platform_wait_t>;\n+\n inline __wait_result_type\n- __spin_impl(const __platform_wait_t* __addr, const __wait_args_base* __args)\n+ __spin_impl(const __platform_wait_t* __addr, const __wait_args_base& __args)\n {\n __platform_wait_t __val;\n for (auto __i = 0; __i < __atomic_spin_count; ++__i)\n \t{\n-\t __atomic_load(__addr, &__val, __args->_M_order);\n-\t if (__val != __args->_M_old)\n-\t return make_pair(true, __val);\n+\t __atomic_load(__addr, &__val, __args._M_order);\n+\t if (__val != __args._M_old)\n+\t return { true, __val };\n \t if (__i < __atomic_spin_count_relax)\n \t __detail::__thread_relax();\n \t else\n \t __detail::__thread_yield();\n \t}\n- return make_pair(false, __val);\n+ return { false, __val };\n }\n \n inline __wait_result_type\n- __wait_impl(const __platform_wait_t* __addr, const __wait_args_base* __a)\n+ __wait_impl(const __platform_wait_t* __addr, const __wait_args_base& __a)\n {\n- __wait_args __args{ *__a };\n-#ifdef _GLIBCXX_HAVE_PLATFORM_WAIT\n+ __wait_args_base __args = __a;\n __waiter_pool_impl* __pool = nullptr;\n-#else\n- // if we don't have __platform_wait, we always need the side-table\n- __waiter_pool_impl* __pool = &__waiter_pool_impl::_S_impl_for(__addr);\n-#endif\n \n- __platform_wait_t* __wait_addr;\n- __platform_wait_t __old;\n+ const __platform_wait_t* __wait_addr;\n if (__args & __wait_flags::__proxy_wait)\n \t{\n-#ifdef _GLIBCXX_HAVE_PLATFORM_WAIT\n \t __pool = &__waiter_pool_impl::_S_impl_for(__addr);\n-#endif\n \t __wait_addr = &__pool->_M_ver;\n-\t __atomic_load(__wait_addr, &__old, __args._M_order);\n+\t __atomic_load(__wait_addr, &__args._M_old, __args._M_order);\n \t}\n else\n-\t{\n-\t __wait_addr = const_cast<__platform_wait_t*>(__addr);\n-\t __old = __args._M_old;\n-\t}\n-\n+\t__wait_addr = __addr;\n \n if (__args & __wait_flags::__do_spin)\n \t{\n-\t auto __res = __detail::__spin_impl(__wait_addr, __a);\n+\t auto __res = __detail::__spin_impl(__wait_addr, __args);\n \t if (__res.first)\n \t return __res;\n \t if (__args & __wait_flags::__spin_only)\n \t return __res;\n \t}\n \n- if (!(__args & __wait_flags::__track_contention))\n-\t{\n-\t // caller does not externally track contention\n-#ifdef _GLIBCXX_HAVE_PLATFORM_WAIT\n-\t __pool = (__pool == nullptr) ? &__waiter_pool_impl::_S_impl_for(__addr)\n-\t\t\t\t : __pool;\n-#endif\n-\t __pool->_M_enter_wait();\n-\t}\n+ auto __tracker = __waiter_pool_impl::_S_track(__pool, __args, __addr);\n \n- __wait_result_type __res;\n #ifdef _GLIBCXX_HAVE_PLATFORM_WAIT\n __platform_wait(__wait_addr, __args._M_old);\n- __res = make_pair(false, __args._M_old);\n+ return { false, __args._M_old };\n #else\n __platform_wait_t __val;\n __atomic_load(__wait_addr, &__val, __args._M_order);\n if (__val == __args._M_old)\n \t{\n+\t if (!__pool)\n+\t __pool = &__waiter_pool_impl::_S_impl_for(__addr);\n \t lock_guard<mutex> __l{ __pool->_M_mtx };\n \t __atomic_load(__wait_addr, &__val, __args._M_order);\n \t if (__val == __args._M_old)\n \t __pool->_M_cv.wait(__pool->_M_mtx);\n \t}\n- __res = make_pair(false, __val);\n+ return { false, __val };\n #endif\n-\n- if (!(__args & __wait_flags::__track_contention))\n-\t// caller does not externally track contention\n-\t__pool->_M_leave_wait();\n- return __res;\n }\n \n inline void\n __notify_impl(const __platform_wait_t* __addr, [[maybe_unused]] bool __all,\n-\t\t const __wait_args_base* __a)\n+\t\t const __wait_args_base& __args)\n {\n- __wait_args __args{ __a };\n-#ifdef _GLIBCXX_HAVE_PLATFORM_WAIT\n __waiter_pool_impl* __pool = nullptr;\n-#else\n- // if we don't have __platform_notify, we always need the side-table\n- __waiter_pool_impl* __pool = &__waiter_pool_impl::_S_impl_for(__addr);\n-#endif\n \n- if (!(__args & __wait_flags::__track_contention))\n+ if (__args & __wait_flags::__track_contention)\n \t{\n-#ifdef _GLIBCXX_HAVE_PLATFORM_WAIT\n \t __pool = &__waiter_pool_impl::_S_impl_for(__addr);\n-#endif\n \t if (!__pool->_M_waiting())\n \t return;\n \t}\n \n- __platform_wait_t* __wait_addr;\n+ const __platform_wait_t* __wait_addr;\n if (__args & __wait_flags::__proxy_wait)\n \t{\n-#ifdef _GLIBCXX_HAVE_PLATFORM_WAIT\n-\t __pool = (__pool == nullptr) ? &__waiter_pool_impl::_S_impl_for(__addr)\n-\t\t\t\t\t: __pool;\n-#endif\n-\t __wait_addr = &__pool->_M_ver;\n-\t __atomic_fetch_add(__wait_addr, 1, __ATOMIC_RELAXED);\n-\t __all = true;\n-\t }\n+\t if (!__pool)\n+\t __pool = &__waiter_pool_impl::_S_impl_for(__addr);\n+\t // Waiting for *__addr is actually done on the proxy's _M_ver.\n+\t __wait_addr = &__pool->_M_ver;\n+\t __atomic_fetch_add(&__pool->_M_ver, 1, __ATOMIC_RELAXED);\n+\t // Because the proxy might be shared by several waiters waiting\n+\t // on different atomic variables, we need to wake them all so\n+\t // they can re-evaluate their conditions to see if they should\n+\t // stop waiting or should wait again.\n+\t __all = true;\n+\t}\n+ else // Use the atomic variable's own address.\n+\t__wait_addr = __addr;\n \n #ifdef _GLIBCXX_HAVE_PLATFORM_WAIT\n __platform_notify(__wait_addr, __all);\n #else\n+ if (!__pool)\n+\t__pool = &__waiter_pool_impl::_S_impl_for(__addr);\n lock_guard<mutex> __l{ __pool->_M_mtx };\n __pool->_M_cv.notify_all();\n #endif\n }\n } // namespace __detail\n \n- template<typename _Tp,\n-\t typename _Pred, typename _ValFn>\n+ // Wait on __addr while __pred(__vfn()) is false.\n+ // If __bare_wait is false, increment a counter while waiting.\n+ // For callers that keep their own count of waiters, use __bare_wait=true.\n+ template<typename _Tp, typename _Pred, typename _ValFn>\n void\n- __atomic_wait_address(const _Tp* __addr,\n-\t\t\t _Pred&& __pred, _ValFn&& __vfn,\n+ __atomic_wait_address(const _Tp* __addr, _Pred&& __pred, _ValFn&& __vfn,\n \t\t\t bool __bare_wait = false) noexcept\n {\n const auto __wait_addr =\n@@ -446,7 +455,14 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION\n _Tp __val = __vfn();\n while (!__pred(__val))\n \t{\n-\t __detail::__wait_impl(__wait_addr, &__args);\n+\t // If the wait is not proxied, set the value that we're waiting\n+\t // to change.\n+\t if constexpr (__platform_wait_uses_type<_Tp>)\n+\t __args._M_old = __builtin_bit_cast(__detail::__platform_wait_t,\n+\t\t\t\t\t __val);\n+\t // Otherwise, it's a proxy wait and the proxy's _M_ver is used.\n+\n+\t __detail::__wait_impl(__wait_addr, __args);\n \t __val = __vfn();\n \t}\n // C++26 will return __val\n@@ -459,9 +475,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION\n {\n __detail::__wait_args __args{ __addr, __old, __order };\n // C++26 will not ignore the return value here\n- __detail::__wait_impl(__addr, &__args);\n+ __detail::__wait_impl(__addr, __args);\n }\n \n+ // Wait on __addr while __vfn() == __old is true.\n template<typename _Tp, typename _ValFn>\n void\n __atomic_wait_address_v(const _Tp* __addr, _Tp __old,\n@@ -480,7 +497,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION\n const auto __wait_addr =\n \t reinterpret_cast<const __detail::__platform_wait_t*>(__addr);\n __detail::__wait_args __args{ __addr, __bare_wait };\n- __detail::__notify_impl(__wait_addr, __all, &__args);\n+ __detail::__notify_impl(__wait_addr, __all, __args);\n }\n _GLIBCXX_END_NAMESPACE_VERSION\n } // namespace std\ndiff --git a/libstdc++-v3/include/std/latch b/libstdc++-v3/include/std/latch\nindex dc54a862c057..0a5bb0fdc6c4 100644\n--- a/libstdc++-v3/include/std/latch\n+++ b/libstdc++-v3/include/std/latch\n@@ -89,8 +89,12 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION\n _GLIBCXX_ALWAYS_INLINE void\n wait() const noexcept\n {\n- auto const __vfn = [this] { return this->try_wait(); };\n- auto const __pred = [this](bool __b) { return __b; };\n+ auto const __vfn = [this] {\n+\treturn __atomic_impl::load(&_M_a, memory_order::acquire);\n+ };\n+ auto const __pred = [](__detail::__platform_wait_t __v) {\n+\treturn __v == 0;\n+ };\n std::__atomic_wait_address(&_M_a, __pred, __vfn);\n }\n \ndiff --git a/libstdc++-v3/testsuite/29_atomics/atomic_integral/wait_notify.cc b/libstdc++-v3/testsuite/29_atomics/atomic_integral/wait_notify.cc\nindex c7f8779e4fb2..6e74f2c53ded 100644\n--- a/libstdc++-v3/testsuite/29_atomics/atomic_integral/wait_notify.cc\n+++ b/libstdc++-v3/testsuite/29_atomics/atomic_integral/wait_notify.cc\n@@ -33,12 +33,16 @@ template<typename Tp>\n std::atomic<Tp> a{ Tp(1) };\n VERIFY( a.load() == Tp(1) );\n a.wait( Tp(0) );\n+ std::atomic<bool> b{false};\n std::thread t([&]\n {\n- a.store(Tp(0));\n- a.notify_one();\n+\tb.store(true, std::memory_order_relaxed);\n+\ta.store(Tp(0));\n+\ta.notify_one();\n });\n a.wait(Tp(1));\n+ // Ensure we actually waited until a.store(0) happened:\n+ VERIFY( b.load(std::memory_order_relaxed) );\n t.join();\n }\n \n", "prefixes": [ "v1", "04/16" ] }