* [patch] libstdc++/57250 shared_ptr atomic operations
@ 2014-10-17 18:28 Jonathan Wakely
2014-11-13 0:10 ` Jonathan Wakely
0 siblings, 1 reply; 2+ messages in thread
From: Jonathan Wakely @ 2014-10-17 18:28 UTC (permalink / raw)
To: libstdc++, gcc-patches
[-- Attachment #1: Type: text/plain, Size: 433 bytes --]
I'm not very proud of this solution, but unless anyone has a better
ideas this is how I plan to add the atomic operations for shared_ptr.
I used __gnu_cxx::__mutex instead of std::mutex because it has fewer
dependencies, so the atomic operations should always be available for
shared_ptr even when the target doesn't support C++11 threads.
The operations are also defined for the __shared_ptr class template.
Tested x86_64-linux.
[-- Attachment #2: patch.txt --]
[-- Type: text/x-patch, Size: 19728 bytes --]
commit 52bec3a5a3c0a1a642981969aa1c32cb64f15453
Author: Jonathan Wakely <jwakely@redhat.com>
Date: Fri Oct 17 18:56:46 2014 +0100
PR libstdc++/57250
* config/abi/pre/gnu.ver: Export new symbols.
* include/Makefile.am: Add new header.
* include/Makefile.in: Regenerate.
* include/bits/shared_ptr_atomic.h: Define atomic access functions.
* include/std/memory: Include new header.
* src/c++11/shared_ptr.cc (_Sp_locker): Define and use mutex pool.
* testsuite/20_util/shared_ptr/atomic/1.cc: New.
* testsuite/20_util/shared_ptr/atomic/2.cc: New.
* testsuite/20_util/shared_ptr/atomic/3.cc: New.
diff --git a/libstdc++-v3/config/abi/pre/gnu.ver b/libstdc++-v3/config/abi/pre/gnu.ver
index 0559444..b91162d 100644
--- a/libstdc++-v3/config/abi/pre/gnu.ver
+++ b/libstdc++-v3/config/abi/pre/gnu.ver
@@ -1473,6 +1473,9 @@ GLIBCXX_3.4.21 {
# std::basic_ios::operator bool() const
_ZNKSt9basic_iosI[cw]St11char_traitsI[cw]EEcvbEv;
+ # std::_Sp_locker::*
+ _ZNSt10_Sp_locker[CD]*;
+
} GLIBCXX_3.4.20;
diff --git a/libstdc++-v3/include/Makefile.am b/libstdc++-v3/include/Makefile.am
index 1ee8ddc..3396535 100644
--- a/libstdc++-v3/include/Makefile.am
+++ b/libstdc++-v3/include/Makefile.am
@@ -143,6 +143,7 @@ bits_headers = \
${bits_srcdir}/stream_iterator.h \
${bits_srcdir}/streambuf_iterator.h \
${bits_srcdir}/shared_ptr.h \
+ ${bits_srcdir}/shared_ptr_atomic.h \
${bits_srcdir}/shared_ptr_base.h \
${bits_srcdir}/slice_array.h \
${bits_srcdir}/sstream.tcc \
diff --git a/libstdc++-v3/include/bits/shared_ptr_atomic.h b/libstdc++-v3/include/bits/shared_ptr_atomic.h
new file mode 100644
index 0000000..79e35ec
--- /dev/null
+++ b/libstdc++-v3/include/bits/shared_ptr_atomic.h
@@ -0,0 +1,330 @@
+// shared_ptr atomic access -*- C++ -*-
+
+// Copyright (C) 2014 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.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file bits/shared_ptr_atomic.h
+ * This is an internal header file, included by other library headers.
+ * Do not attempt to use it directly. @headername{memory}
+ */
+
+#ifndef _SHARED_PTR_ATOMIC_H
+#define _SHARED_PTR_ATOMIC_H 1
+
+#include <bits/atomic_base.h>
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+ /**
+ * @addtogroup pointer_abstractions
+ * @{
+ */
+
+ struct _Sp_locker
+ {
+ _Sp_locker(const _Sp_locker&) = delete;
+ _Sp_locker& operator=(const _Sp_locker&) = delete;
+
+#ifdef __GTHREADS
+ explicit
+ _Sp_locker(const void*) noexcept;
+ _Sp_locker(const void*, const void*) noexcept;
+ ~_Sp_locker();
+
+ private:
+ unsigned char _M_key1;
+ unsigned char _M_key2;
+#else
+ explicit _Sp_locker(const void*, const void* = nullptr) { }
+#endif
+ };
+
+ /**
+ * @brief Report whether shared_ptr atomic operations are lock-free.
+ * @param __p A non-null pointer to a shared_ptr object.
+ * @return True if atomic access to @c *__p is lock-free, false otherwise.
+ * @{
+ */
+ template<typename _Tp, _Lock_policy _Lp>
+ inline bool
+ atomic_is_lock_free(const __shared_ptr<_Tp, _Lp>* __p)
+ {
+#ifdef __GTHREADS
+ return __gthread_active_p() == 0;
+#else
+ return true;
+#endif
+ }
+
+ template<typename _Tp>
+ inline bool
+ atomic_is_lock_free(const shared_ptr<_Tp>* __p)
+ { return std::atomic_is_lock_free<_Tp, __default_lock_policy>(__p); }
+
+ // @}
+
+ /**
+ * @brief Atomic load for shared_ptr objects.
+ * @param __p A non-null pointer to a shared_ptr object.
+ * @return @c *__p
+ *
+ * The memory order shall not be @c memory_order_release or
+ * @c memory_order_acq_rel.
+ * @{
+ */
+ template<typename _Tp>
+ inline shared_ptr<_Tp>
+ atomic_load_explicit(const shared_ptr<_Tp>* __p, memory_order)
+ {
+ _Sp_locker __lock{__p};
+ return *__p;
+ }
+
+ template<typename _Tp>
+ inline shared_ptr<_Tp>
+ atomic_load(const shared_ptr<_Tp>* __p)
+ { return std::atomic_load_explicit(__p, memory_order_seq_cst); }
+
+ template<typename _Tp, _Lock_policy _Lp>
+ inline __shared_ptr<_Tp, _Lp>
+ atomic_load_explicit(const __shared_ptr<_Tp, _Lp>* __p, memory_order)
+ {
+ _Sp_locker __lock{__p};
+ return *__p;
+ }
+
+ template<typename _Tp, _Lock_policy _Lp>
+ inline __shared_ptr<_Tp, _Lp>
+ atomic_load(const __shared_ptr<_Tp, _Lp>* __p)
+ { return std::atomic_load_explicit(__p, memory_order_seq_cst); }
+ // @}
+
+ /**
+ * @brief Atomic store for shared_ptr objects.
+ * @param __p A non-null pointer to a shared_ptr object.
+ * @param __r The value to store.
+ *
+ * The memory order shall not be @c memory_order_acquire or
+ * @c memory_order_acq_rel.
+ * @{
+ */
+ template<typename _Tp>
+ inline void
+ atomic_store_explicit(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r,
+ memory_order)
+ {
+ _Sp_locker __lock{__p};
+ __p->swap(__r); // use swap so that **__p not destroyed while lock held
+ }
+
+ template<typename _Tp>
+ inline void
+ atomic_store(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r)
+ { std::atomic_store_explicit(__p, std::move(__r), memory_order_seq_cst); }
+
+ template<typename _Tp, _Lock_policy _Lp>
+ inline void
+ atomic_store_explicit(__shared_ptr<_Tp, _Lp>* __p,
+ __shared_ptr<_Tp, _Lp> __r,
+ memory_order)
+ {
+ _Sp_locker __lock{__p};
+ __p->swap(__r); // use swap so that **__p not destroyed while lock held
+ }
+
+ template<typename _Tp, _Lock_policy _Lp>
+ inline void
+ atomic_store(__shared_ptr<_Tp, _Lp>* __p, __shared_ptr<_Tp, _Lp> __r)
+ { std::atomic_store_explicit(__p, std::move(__r), memory_order_seq_cst); }
+ // @}
+
+ /**
+ * @brief Atomic exchange for shared_ptr objects.
+ * @param __p A non-null pointer to a shared_ptr object.
+ * @param __r New value to store in @c *__p.
+ * @return The original value of @c *__p
+ * @{
+ */
+ template<typename _Tp>
+ inline shared_ptr<_Tp>
+ atomic_exchange_explicit(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r,
+ memory_order)
+ {
+ _Sp_locker __lock{__p};
+ __p->swap(__r);
+ return __r;
+ }
+
+ template<typename _Tp>
+ inline shared_ptr<_Tp>
+ atomic_exchange(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r)
+ {
+ return std::atomic_exchange_explicit(__p, std::move(__r),
+ memory_order_seq_cst);
+ }
+
+ template<typename _Tp, _Lock_policy _Lp>
+ inline __shared_ptr<_Tp, _Lp>
+ atomic_exchange_explicit(__shared_ptr<_Tp, _Lp>* __p,
+ __shared_ptr<_Tp, _Lp> __r,
+ memory_order)
+ {
+ _Sp_locker __lock{__p};
+ __p->swap(__r);
+ return __r;
+ }
+
+ template<typename _Tp, _Lock_policy _Lp>
+ inline __shared_ptr<_Tp, _Lp>
+ atomic_exchange(__shared_ptr<_Tp, _Lp>* __p, __shared_ptr<_Tp, _Lp> __r)
+ {
+ return std::atomic_exchange_explicit(__p, std::move(__r),
+ memory_order_seq_cst);
+ }
+ // @}
+
+ /**
+ * @brief Atomic compare-and-swap for shared_ptr objects.
+ * @param __p A non-null pointer to a shared_ptr object.
+ * @param __v A non-null pointer to a shared_ptr object.
+ * @param __w A non-null pointer to a shared_ptr object.
+ * @return True if @c *__p was equivalent to @c *__v, false otherwise.
+ *
+ * The memory order for failure shall not be @c memory_order_release or
+ * @c memory_order_acq_rel, or stronger than the memory order for success.
+ * @{
+ */
+ template<typename _Tp>
+ bool
+ atomic_compare_exchange_strong_explicit(shared_ptr<_Tp>* __p,
+ shared_ptr<_Tp>* __v,
+ shared_ptr<_Tp> __w,
+ memory_order,
+ memory_order)
+ {
+ shared_ptr<_Tp> __x; // goes out of scope after __lock
+ _Sp_locker __lock{__p, __v};
+ owner_less<shared_ptr<_Tp>> __less;
+ if (*__p == *__v && !__less(*__p, *__v) && !__less(*__v, *__p))
+ {
+ __x = std::move(*__p);
+ *__p = std::move(__w);
+ return true;
+ }
+ __x = std::move(*__v);
+ *__v = *__p;
+ return false;
+ }
+
+ template<typename _Tp>
+ inline bool
+ atomic_compare_exchange_strong(shared_ptr<_Tp>* __p, shared_ptr<_Tp>* __v,
+ shared_ptr<_Tp> __w)
+ {
+ return std::atomic_compare_exchange_strong_explicit(__p, __v,
+ std::move(__w), memory_order_seq_cst, memory_order_seq_cst);
+ }
+
+ template<typename _Tp>
+ inline bool
+ atomic_compare_exchange_weak_explicit(shared_ptr<_Tp>* __p,
+ shared_ptr<_Tp>* __v,
+ shared_ptr<_Tp> __w,
+ memory_order __success,
+ memory_order __failure)
+ {
+ return std::atomic_compare_exchange_strong_explicit(__p, __v,
+ std::move(__w), __success, __failure);
+ }
+
+ template<typename _Tp>
+ inline bool
+ atomic_compare_exchange_weak(shared_ptr<_Tp>* __p, shared_ptr<_Tp>* __v,
+ shared_ptr<_Tp> __w)
+ {
+ return std::atomic_compare_exchange_weak_explicit(__p, __v,
+ std::move(__w), memory_order_seq_cst, memory_order_seq_cst);
+ }
+
+ template<typename _Tp, _Lock_policy _Lp>
+ bool
+ atomic_compare_exchange_strong_explicit(__shared_ptr<_Tp, _Lp>* __p,
+ __shared_ptr<_Tp, _Lp>* __v,
+ __shared_ptr<_Tp, _Lp> __w,
+ memory_order,
+ memory_order)
+ {
+ __shared_ptr<_Tp, _Lp> __x; // goes out of scope after __lock
+ _Sp_locker __lock{__p, __v};
+ owner_less<__shared_ptr<_Tp, _Lp>> __less;
+ if (*__p == *__v && !__less(*__p, *__v) && !__less(*__v, *__p))
+ {
+ __x = std::move(*__p);
+ *__p = std::move(__w);
+ return true;
+ }
+ __x = std::move(*__v);
+ *__v = *__p;
+ return false;
+ }
+
+ template<typename _Tp, _Lock_policy _Lp>
+ inline bool
+ atomic_compare_exchange_strong(__shared_ptr<_Tp, _Lp>* __p,
+ __shared_ptr<_Tp, _Lp>* __v,
+ __shared_ptr<_Tp, _Lp> __w)
+ {
+ return std::atomic_compare_exchange_strong_explicit(__p, __v,
+ std::move(__w), memory_order_seq_cst, memory_order_seq_cst);
+ }
+
+ template<typename _Tp, _Lock_policy _Lp>
+ inline bool
+ atomic_compare_exchange_weak_explicit(__shared_ptr<_Tp, _Lp>* __p,
+ __shared_ptr<_Tp, _Lp>* __v,
+ __shared_ptr<_Tp, _Lp> __w,
+ memory_order __success,
+ memory_order __failure)
+ {
+ return std::atomic_compare_exchange_strong_explicit(__p, __v,
+ std::move(__w), __success, __failure);
+ }
+
+ template<typename _Tp, _Lock_policy _Lp>
+ inline bool
+ atomic_compare_exchange_weak(__shared_ptr<_Tp, _Lp>* __p,
+ __shared_ptr<_Tp, _Lp>* __v,
+ __shared_ptr<_Tp, _Lp> __w)
+ {
+ return std::atomic_compare_exchange_weak_explicit(__p, __v,
+ std::move(__w), memory_order_seq_cst, memory_order_seq_cst);
+ }
+ // @}
+
+ // @} group pointer_abstractions
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+#endif // _SHARED_PTR_ATOMIC_H
diff --git a/libstdc++-v3/include/std/memory b/libstdc++-v3/include/std/memory
index b5792ad..3d1c8a9 100644
--- a/libstdc++-v3/include/std/memory
+++ b/libstdc++-v3/include/std/memory
@@ -80,6 +80,7 @@
# include <debug/debug.h>
# include <bits/unique_ptr.h>
# include <bits/shared_ptr.h>
+# include <bits/shared_ptr_atomic.h>
# if _GLIBCXX_USE_DEPRECATED
# include <backward/auto_ptr.h>
# endif
diff --git a/libstdc++-v3/src/c++11/shared_ptr.cc b/libstdc++-v3/src/c++11/shared_ptr.cc
index 53b3452..9247532 100644
--- a/libstdc++-v3/src/c++11/shared_ptr.cc
+++ b/libstdc++-v3/src/c++11/shared_ptr.cc
@@ -34,5 +34,63 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
bad_weak_ptr::what() const noexcept
{ return "bad_weak_ptr"; }
+#ifdef __GTHREADS
+ namespace
+ {
+ const unsigned char mask = 0xf;
+ const unsigned char invalid = mask + 1;
+
+ inline unsigned char key(const void* addr)
+ { return _Hash_impl::hash(addr) & mask; }
+
+ /* Returns different instances of __mutex depending on the passed address
+ * in order to limit contention.
+ */
+ __gnu_cxx::__mutex&
+ get_mutex(unsigned char i)
+ {
+ static __gnu_cxx::__mutex m[mask + 1];
+ return m[i];
+ }
+ }
+
+ _Sp_locker::_Sp_locker(const void* p)
+ {
+ if (__gthread_active_p())
+ {
+ _M_key1 = _M_key2 = key(p);
+ get_mutex(_M_key1).lock();
+ }
+ else
+ _M_key1 = _M_key2 = invalid;
+ }
+
+ _Sp_locker::_Sp_locker(const void* p1, const void* p2)
+ {
+ if (__gthread_active_p())
+ {
+ _M_key1 = key(p1);
+ _M_key2 = key(p2);
+ if (_M_key2 < _M_key1)
+ get_mutex(_M_key2).lock();
+ get_mutex(_M_key1).lock();
+ if (_M_key2 > _M_key1)
+ get_mutex(_M_key2).lock();
+ }
+ else
+ _M_key1 = _M_key2 = invalid;
+ }
+
+ _Sp_locker::~_Sp_locker()
+ {
+ if (_M_key1 != invalid)
+ {
+ get_mutex(_M_key1).unlock();
+ if (_M_key2 != _M_key1)
+ get_mutex(_M_key2).unlock();
+ }
+ }
+#endif
+
_GLIBCXX_END_NAMESPACE_VERSION
} // namespace
diff --git a/libstdc++-v3/testsuite/20_util/shared_ptr/atomic/1.cc b/libstdc++-v3/testsuite/20_util/shared_ptr/atomic/1.cc
new file mode 100644
index 0000000..37ab333
--- /dev/null
+++ b/libstdc++-v3/testsuite/20_util/shared_ptr/atomic/1.cc
@@ -0,0 +1,40 @@
+// Copyright (C) 2014 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-gthreads "" }
+
+#include <memory>
+
+int main()
+{
+ using test_type = std::shared_ptr<int>;
+ bool test __attribute__ ((unused)) = false;
+ constexpr auto mo = std::memory_order_seq_cst;
+ const test_type p;
+ test = std::atomic_is_lock_free(&p);
+ test_type p2 = std::atomic_load(&p);
+ test_type p3 = std::atomic_load_explicit(&p, mo);
+ std::atomic_store(&p2, p);
+ std::atomic_store_explicit(&p2, p, mo);
+ test_type p4 = std::atomic_exchange(&p2, p);
+ p4 = std::atomic_exchange_explicit(&p2, p, mo);
+ test = std::atomic_compare_exchange_weak(&p2, &p3, p);
+ test = std::atomic_compare_exchange_strong(&p2, &p3, p);
+ test = std::atomic_compare_exchange_weak_explicit(&p2, &p3, p, mo, mo);
+ test = std::atomic_compare_exchange_strong_explicit(&p2, &p3, p, mo, mo);
+}
diff --git a/libstdc++-v3/testsuite/20_util/shared_ptr/atomic/2.cc b/libstdc++-v3/testsuite/20_util/shared_ptr/atomic/2.cc
new file mode 100644
index 0000000..846a663
--- /dev/null
+++ b/libstdc++-v3/testsuite/20_util/shared_ptr/atomic/2.cc
@@ -0,0 +1,40 @@
+// Copyright (C) 2014 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-gthreads "" }
+
+#include <memory>
+
+int main()
+{
+ using test_type = std::__shared_ptr<int, std::_S_single>;
+ bool test __attribute__ ((unused)) = false;
+ constexpr auto mo = std::memory_order_seq_cst;
+ const test_type p;
+ test = std::atomic_is_lock_free(&p);
+ test_type p2 = std::atomic_load(&p);
+ test_type p3 = std::atomic_load_explicit(&p, mo);
+ std::atomic_store(&p2, p);
+ std::atomic_store_explicit(&p2, p, mo);
+ test_type p4 = std::atomic_exchange(&p2, p);
+ p4 = std::atomic_exchange_explicit(&p2, p, mo);
+ test = std::atomic_compare_exchange_weak(&p2, &p3, p);
+ test = std::atomic_compare_exchange_strong(&p2, &p3, p);
+ test = std::atomic_compare_exchange_weak_explicit(&p2, &p3, p, mo, mo);
+ test = std::atomic_compare_exchange_strong_explicit(&p2, &p3, p, mo, mo);
+}
diff --git a/libstdc++-v3/testsuite/20_util/shared_ptr/atomic/3.cc b/libstdc++-v3/testsuite/20_util/shared_ptr/atomic/3.cc
new file mode 100644
index 0000000..f964806
--- /dev/null
+++ b/libstdc++-v3/testsuite/20_util/shared_ptr/atomic/3.cc
@@ -0,0 +1,53 @@
+// { dg-do run { target *-*-freebsd* *-*-dragonfly* *-*-netbsd* *-*-linux* *-*-gnu* *-*-solaris* *-*-cygwin *-*-darwin* powerpc-ibm-aix* } }
+// { dg-options " -std=gnu++11 -pthread" { target *-*-freebsd* *-*-dragonfly* *-*-netbsd* *-*-linux* *-*-gnu* powerpc-ibm-aix* } }
+// { dg-options " -std=gnu++11 -pthreads" { target *-*-solaris* } }
+// { dg-options " -std=gnu++11 " { target *-*-cygwin *-*-darwin* } }
+// { dg-require-cstdint "" }
+// { dg-require-gthreads "" }
+
+// Copyright (C) 2014 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/>.
+
+#include <thread>
+#include <memory>
+#include <testsuite_hooks.h>
+
+struct leaddock
+{
+ ~leaddock();
+};
+
+std::shared_ptr<leaddock> global;
+
+leaddock::~leaddock()
+{
+ // If this destructor is called "inside" an atomic operation on global it
+ // will deadlock, so this checks that the atomic_store is done atomically.
+ auto copy = std::atomic_load(&global);
+ VERIFY( !copy );
+}
+
+void f()
+{
+ std::atomic_store(&global, std::make_shared<leaddock>());
+ std::atomic_store(&global, {});
+}
+
+int main()
+{
+ std::thread{ f }.join();
+}
^ permalink raw reply [flat|nested] 2+ messages in thread
* Re: [patch] libstdc++/57250 shared_ptr atomic operations
2014-10-17 18:28 [patch] libstdc++/57250 shared_ptr atomic operations Jonathan Wakely
@ 2014-11-13 0:10 ` Jonathan Wakely
0 siblings, 0 replies; 2+ messages in thread
From: Jonathan Wakely @ 2014-11-13 0:10 UTC (permalink / raw)
To: libstdc++, gcc-patches
[-- Attachment #1: Type: text/plain, Size: 548 bytes --]
On 17/10/14 19:27 +0100, Jonathan Wakely wrote:
>I'm not very proud of this solution, but unless anyone has a better
>ideas this is how I plan to add the atomic operations for shared_ptr.
>
>I used __gnu_cxx::__mutex instead of std::mutex because it has fewer
>dependencies, so the atomic operations should always be available for
>shared_ptr even when the target doesn't support C++11 threads.
>
>The operations are also defined for the __shared_ptr class template.
>
>Tested x86_64-linux.
And also tested on powerpc64-linux. Committed to trunk.
[-- Attachment #2: patch.txt --]
[-- Type: text/x-patch, Size: 19732 bytes --]
commit a4a18a1822e9215c141f205ed0d2f16e88f0138e
Author: Jonathan Wakely <jwakely@redhat.com>
Date: Fri Oct 17 18:56:46 2014 +0100
std::shared_ptr atomic operations
PR libstdc++/57250
* config/abi/pre/gnu.ver: Export new symbols.
* include/Makefile.am: Add new header.
* include/Makefile.in: Regenerate.
* include/bits/shared_ptr_atomic.h: Define atomic access functions.
* include/std/memory: Include new header.
* src/c++11/shared_ptr.cc (_Sp_locker): Define and use mutex pool.
* testsuite/20_util/shared_ptr/atomic/1.cc: New.
* testsuite/20_util/shared_ptr/atomic/2.cc: New.
* testsuite/20_util/shared_ptr/atomic/3.cc: New.
diff --git a/libstdc++-v3/config/abi/pre/gnu.ver b/libstdc++-v3/config/abi/pre/gnu.ver
index 4c6d994..bd44bcc 100644
--- a/libstdc++-v3/config/abi/pre/gnu.ver
+++ b/libstdc++-v3/config/abi/pre/gnu.ver
@@ -1476,6 +1476,9 @@ GLIBCXX_3.4.21 {
# std::ctype_base::blank
_ZNSt10ctype_base5blankE;
+ # std::_Sp_locker::*
+ _ZNSt10_Sp_locker[CD]*;
+
} GLIBCXX_3.4.20;
diff --git a/libstdc++-v3/include/Makefile.am b/libstdc++-v3/include/Makefile.am
index 5fa243b..e6edc73 100644
--- a/libstdc++-v3/include/Makefile.am
+++ b/libstdc++-v3/include/Makefile.am
@@ -143,6 +143,7 @@ bits_headers = \
${bits_srcdir}/stream_iterator.h \
${bits_srcdir}/streambuf_iterator.h \
${bits_srcdir}/shared_ptr.h \
+ ${bits_srcdir}/shared_ptr_atomic.h \
${bits_srcdir}/shared_ptr_base.h \
${bits_srcdir}/slice_array.h \
${bits_srcdir}/sstream.tcc \
diff --git a/libstdc++-v3/include/bits/shared_ptr_atomic.h b/libstdc++-v3/include/bits/shared_ptr_atomic.h
new file mode 100644
index 0000000..79e35ec
--- /dev/null
+++ b/libstdc++-v3/include/bits/shared_ptr_atomic.h
@@ -0,0 +1,330 @@
+// shared_ptr atomic access -*- C++ -*-
+
+// Copyright (C) 2014 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.
+
+// Under Section 7 of GPL version 3, you are granted additional
+// permissions described in the GCC Runtime Library Exception, version
+// 3.1, as published by the Free Software Foundation.
+
+// You should have received a copy of the GNU General Public License and
+// a copy of the GCC Runtime Library Exception along with this program;
+// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
+// <http://www.gnu.org/licenses/>.
+
+/** @file bits/shared_ptr_atomic.h
+ * This is an internal header file, included by other library headers.
+ * Do not attempt to use it directly. @headername{memory}
+ */
+
+#ifndef _SHARED_PTR_ATOMIC_H
+#define _SHARED_PTR_ATOMIC_H 1
+
+#include <bits/atomic_base.h>
+
+namespace std _GLIBCXX_VISIBILITY(default)
+{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
+ /**
+ * @addtogroup pointer_abstractions
+ * @{
+ */
+
+ struct _Sp_locker
+ {
+ _Sp_locker(const _Sp_locker&) = delete;
+ _Sp_locker& operator=(const _Sp_locker&) = delete;
+
+#ifdef __GTHREADS
+ explicit
+ _Sp_locker(const void*) noexcept;
+ _Sp_locker(const void*, const void*) noexcept;
+ ~_Sp_locker();
+
+ private:
+ unsigned char _M_key1;
+ unsigned char _M_key2;
+#else
+ explicit _Sp_locker(const void*, const void* = nullptr) { }
+#endif
+ };
+
+ /**
+ * @brief Report whether shared_ptr atomic operations are lock-free.
+ * @param __p A non-null pointer to a shared_ptr object.
+ * @return True if atomic access to @c *__p is lock-free, false otherwise.
+ * @{
+ */
+ template<typename _Tp, _Lock_policy _Lp>
+ inline bool
+ atomic_is_lock_free(const __shared_ptr<_Tp, _Lp>* __p)
+ {
+#ifdef __GTHREADS
+ return __gthread_active_p() == 0;
+#else
+ return true;
+#endif
+ }
+
+ template<typename _Tp>
+ inline bool
+ atomic_is_lock_free(const shared_ptr<_Tp>* __p)
+ { return std::atomic_is_lock_free<_Tp, __default_lock_policy>(__p); }
+
+ // @}
+
+ /**
+ * @brief Atomic load for shared_ptr objects.
+ * @param __p A non-null pointer to a shared_ptr object.
+ * @return @c *__p
+ *
+ * The memory order shall not be @c memory_order_release or
+ * @c memory_order_acq_rel.
+ * @{
+ */
+ template<typename _Tp>
+ inline shared_ptr<_Tp>
+ atomic_load_explicit(const shared_ptr<_Tp>* __p, memory_order)
+ {
+ _Sp_locker __lock{__p};
+ return *__p;
+ }
+
+ template<typename _Tp>
+ inline shared_ptr<_Tp>
+ atomic_load(const shared_ptr<_Tp>* __p)
+ { return std::atomic_load_explicit(__p, memory_order_seq_cst); }
+
+ template<typename _Tp, _Lock_policy _Lp>
+ inline __shared_ptr<_Tp, _Lp>
+ atomic_load_explicit(const __shared_ptr<_Tp, _Lp>* __p, memory_order)
+ {
+ _Sp_locker __lock{__p};
+ return *__p;
+ }
+
+ template<typename _Tp, _Lock_policy _Lp>
+ inline __shared_ptr<_Tp, _Lp>
+ atomic_load(const __shared_ptr<_Tp, _Lp>* __p)
+ { return std::atomic_load_explicit(__p, memory_order_seq_cst); }
+ // @}
+
+ /**
+ * @brief Atomic store for shared_ptr objects.
+ * @param __p A non-null pointer to a shared_ptr object.
+ * @param __r The value to store.
+ *
+ * The memory order shall not be @c memory_order_acquire or
+ * @c memory_order_acq_rel.
+ * @{
+ */
+ template<typename _Tp>
+ inline void
+ atomic_store_explicit(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r,
+ memory_order)
+ {
+ _Sp_locker __lock{__p};
+ __p->swap(__r); // use swap so that **__p not destroyed while lock held
+ }
+
+ template<typename _Tp>
+ inline void
+ atomic_store(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r)
+ { std::atomic_store_explicit(__p, std::move(__r), memory_order_seq_cst); }
+
+ template<typename _Tp, _Lock_policy _Lp>
+ inline void
+ atomic_store_explicit(__shared_ptr<_Tp, _Lp>* __p,
+ __shared_ptr<_Tp, _Lp> __r,
+ memory_order)
+ {
+ _Sp_locker __lock{__p};
+ __p->swap(__r); // use swap so that **__p not destroyed while lock held
+ }
+
+ template<typename _Tp, _Lock_policy _Lp>
+ inline void
+ atomic_store(__shared_ptr<_Tp, _Lp>* __p, __shared_ptr<_Tp, _Lp> __r)
+ { std::atomic_store_explicit(__p, std::move(__r), memory_order_seq_cst); }
+ // @}
+
+ /**
+ * @brief Atomic exchange for shared_ptr objects.
+ * @param __p A non-null pointer to a shared_ptr object.
+ * @param __r New value to store in @c *__p.
+ * @return The original value of @c *__p
+ * @{
+ */
+ template<typename _Tp>
+ inline shared_ptr<_Tp>
+ atomic_exchange_explicit(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r,
+ memory_order)
+ {
+ _Sp_locker __lock{__p};
+ __p->swap(__r);
+ return __r;
+ }
+
+ template<typename _Tp>
+ inline shared_ptr<_Tp>
+ atomic_exchange(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r)
+ {
+ return std::atomic_exchange_explicit(__p, std::move(__r),
+ memory_order_seq_cst);
+ }
+
+ template<typename _Tp, _Lock_policy _Lp>
+ inline __shared_ptr<_Tp, _Lp>
+ atomic_exchange_explicit(__shared_ptr<_Tp, _Lp>* __p,
+ __shared_ptr<_Tp, _Lp> __r,
+ memory_order)
+ {
+ _Sp_locker __lock{__p};
+ __p->swap(__r);
+ return __r;
+ }
+
+ template<typename _Tp, _Lock_policy _Lp>
+ inline __shared_ptr<_Tp, _Lp>
+ atomic_exchange(__shared_ptr<_Tp, _Lp>* __p, __shared_ptr<_Tp, _Lp> __r)
+ {
+ return std::atomic_exchange_explicit(__p, std::move(__r),
+ memory_order_seq_cst);
+ }
+ // @}
+
+ /**
+ * @brief Atomic compare-and-swap for shared_ptr objects.
+ * @param __p A non-null pointer to a shared_ptr object.
+ * @param __v A non-null pointer to a shared_ptr object.
+ * @param __w A non-null pointer to a shared_ptr object.
+ * @return True if @c *__p was equivalent to @c *__v, false otherwise.
+ *
+ * The memory order for failure shall not be @c memory_order_release or
+ * @c memory_order_acq_rel, or stronger than the memory order for success.
+ * @{
+ */
+ template<typename _Tp>
+ bool
+ atomic_compare_exchange_strong_explicit(shared_ptr<_Tp>* __p,
+ shared_ptr<_Tp>* __v,
+ shared_ptr<_Tp> __w,
+ memory_order,
+ memory_order)
+ {
+ shared_ptr<_Tp> __x; // goes out of scope after __lock
+ _Sp_locker __lock{__p, __v};
+ owner_less<shared_ptr<_Tp>> __less;
+ if (*__p == *__v && !__less(*__p, *__v) && !__less(*__v, *__p))
+ {
+ __x = std::move(*__p);
+ *__p = std::move(__w);
+ return true;
+ }
+ __x = std::move(*__v);
+ *__v = *__p;
+ return false;
+ }
+
+ template<typename _Tp>
+ inline bool
+ atomic_compare_exchange_strong(shared_ptr<_Tp>* __p, shared_ptr<_Tp>* __v,
+ shared_ptr<_Tp> __w)
+ {
+ return std::atomic_compare_exchange_strong_explicit(__p, __v,
+ std::move(__w), memory_order_seq_cst, memory_order_seq_cst);
+ }
+
+ template<typename _Tp>
+ inline bool
+ atomic_compare_exchange_weak_explicit(shared_ptr<_Tp>* __p,
+ shared_ptr<_Tp>* __v,
+ shared_ptr<_Tp> __w,
+ memory_order __success,
+ memory_order __failure)
+ {
+ return std::atomic_compare_exchange_strong_explicit(__p, __v,
+ std::move(__w), __success, __failure);
+ }
+
+ template<typename _Tp>
+ inline bool
+ atomic_compare_exchange_weak(shared_ptr<_Tp>* __p, shared_ptr<_Tp>* __v,
+ shared_ptr<_Tp> __w)
+ {
+ return std::atomic_compare_exchange_weak_explicit(__p, __v,
+ std::move(__w), memory_order_seq_cst, memory_order_seq_cst);
+ }
+
+ template<typename _Tp, _Lock_policy _Lp>
+ bool
+ atomic_compare_exchange_strong_explicit(__shared_ptr<_Tp, _Lp>* __p,
+ __shared_ptr<_Tp, _Lp>* __v,
+ __shared_ptr<_Tp, _Lp> __w,
+ memory_order,
+ memory_order)
+ {
+ __shared_ptr<_Tp, _Lp> __x; // goes out of scope after __lock
+ _Sp_locker __lock{__p, __v};
+ owner_less<__shared_ptr<_Tp, _Lp>> __less;
+ if (*__p == *__v && !__less(*__p, *__v) && !__less(*__v, *__p))
+ {
+ __x = std::move(*__p);
+ *__p = std::move(__w);
+ return true;
+ }
+ __x = std::move(*__v);
+ *__v = *__p;
+ return false;
+ }
+
+ template<typename _Tp, _Lock_policy _Lp>
+ inline bool
+ atomic_compare_exchange_strong(__shared_ptr<_Tp, _Lp>* __p,
+ __shared_ptr<_Tp, _Lp>* __v,
+ __shared_ptr<_Tp, _Lp> __w)
+ {
+ return std::atomic_compare_exchange_strong_explicit(__p, __v,
+ std::move(__w), memory_order_seq_cst, memory_order_seq_cst);
+ }
+
+ template<typename _Tp, _Lock_policy _Lp>
+ inline bool
+ atomic_compare_exchange_weak_explicit(__shared_ptr<_Tp, _Lp>* __p,
+ __shared_ptr<_Tp, _Lp>* __v,
+ __shared_ptr<_Tp, _Lp> __w,
+ memory_order __success,
+ memory_order __failure)
+ {
+ return std::atomic_compare_exchange_strong_explicit(__p, __v,
+ std::move(__w), __success, __failure);
+ }
+
+ template<typename _Tp, _Lock_policy _Lp>
+ inline bool
+ atomic_compare_exchange_weak(__shared_ptr<_Tp, _Lp>* __p,
+ __shared_ptr<_Tp, _Lp>* __v,
+ __shared_ptr<_Tp, _Lp> __w)
+ {
+ return std::atomic_compare_exchange_weak_explicit(__p, __v,
+ std::move(__w), memory_order_seq_cst, memory_order_seq_cst);
+ }
+ // @}
+
+ // @} group pointer_abstractions
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
+#endif // _SHARED_PTR_ATOMIC_H
diff --git a/libstdc++-v3/include/std/memory b/libstdc++-v3/include/std/memory
index b5792ad..3d1c8a9 100644
--- a/libstdc++-v3/include/std/memory
+++ b/libstdc++-v3/include/std/memory
@@ -80,6 +80,7 @@
# include <debug/debug.h>
# include <bits/unique_ptr.h>
# include <bits/shared_ptr.h>
+# include <bits/shared_ptr_atomic.h>
# if _GLIBCXX_USE_DEPRECATED
# include <backward/auto_ptr.h>
# endif
diff --git a/libstdc++-v3/src/c++11/shared_ptr.cc b/libstdc++-v3/src/c++11/shared_ptr.cc
index 53b3452..9247532 100644
--- a/libstdc++-v3/src/c++11/shared_ptr.cc
+++ b/libstdc++-v3/src/c++11/shared_ptr.cc
@@ -34,5 +34,63 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
bad_weak_ptr::what() const noexcept
{ return "bad_weak_ptr"; }
+#ifdef __GTHREADS
+ namespace
+ {
+ const unsigned char mask = 0xf;
+ const unsigned char invalid = mask + 1;
+
+ inline unsigned char key(const void* addr)
+ { return _Hash_impl::hash(addr) & mask; }
+
+ /* Returns different instances of __mutex depending on the passed address
+ * in order to limit contention.
+ */
+ __gnu_cxx::__mutex&
+ get_mutex(unsigned char i)
+ {
+ static __gnu_cxx::__mutex m[mask + 1];
+ return m[i];
+ }
+ }
+
+ _Sp_locker::_Sp_locker(const void* p)
+ {
+ if (__gthread_active_p())
+ {
+ _M_key1 = _M_key2 = key(p);
+ get_mutex(_M_key1).lock();
+ }
+ else
+ _M_key1 = _M_key2 = invalid;
+ }
+
+ _Sp_locker::_Sp_locker(const void* p1, const void* p2)
+ {
+ if (__gthread_active_p())
+ {
+ _M_key1 = key(p1);
+ _M_key2 = key(p2);
+ if (_M_key2 < _M_key1)
+ get_mutex(_M_key2).lock();
+ get_mutex(_M_key1).lock();
+ if (_M_key2 > _M_key1)
+ get_mutex(_M_key2).lock();
+ }
+ else
+ _M_key1 = _M_key2 = invalid;
+ }
+
+ _Sp_locker::~_Sp_locker()
+ {
+ if (_M_key1 != invalid)
+ {
+ get_mutex(_M_key1).unlock();
+ if (_M_key2 != _M_key1)
+ get_mutex(_M_key2).unlock();
+ }
+ }
+#endif
+
_GLIBCXX_END_NAMESPACE_VERSION
} // namespace
diff --git a/libstdc++-v3/testsuite/20_util/shared_ptr/atomic/1.cc b/libstdc++-v3/testsuite/20_util/shared_ptr/atomic/1.cc
new file mode 100644
index 0000000..37ab333
--- /dev/null
+++ b/libstdc++-v3/testsuite/20_util/shared_ptr/atomic/1.cc
@@ -0,0 +1,40 @@
+// Copyright (C) 2014 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-gthreads "" }
+
+#include <memory>
+
+int main()
+{
+ using test_type = std::shared_ptr<int>;
+ bool test __attribute__ ((unused)) = false;
+ constexpr auto mo = std::memory_order_seq_cst;
+ const test_type p;
+ test = std::atomic_is_lock_free(&p);
+ test_type p2 = std::atomic_load(&p);
+ test_type p3 = std::atomic_load_explicit(&p, mo);
+ std::atomic_store(&p2, p);
+ std::atomic_store_explicit(&p2, p, mo);
+ test_type p4 = std::atomic_exchange(&p2, p);
+ p4 = std::atomic_exchange_explicit(&p2, p, mo);
+ test = std::atomic_compare_exchange_weak(&p2, &p3, p);
+ test = std::atomic_compare_exchange_strong(&p2, &p3, p);
+ test = std::atomic_compare_exchange_weak_explicit(&p2, &p3, p, mo, mo);
+ test = std::atomic_compare_exchange_strong_explicit(&p2, &p3, p, mo, mo);
+}
diff --git a/libstdc++-v3/testsuite/20_util/shared_ptr/atomic/2.cc b/libstdc++-v3/testsuite/20_util/shared_ptr/atomic/2.cc
new file mode 100644
index 0000000..846a663
--- /dev/null
+++ b/libstdc++-v3/testsuite/20_util/shared_ptr/atomic/2.cc
@@ -0,0 +1,40 @@
+// Copyright (C) 2014 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-gthreads "" }
+
+#include <memory>
+
+int main()
+{
+ using test_type = std::__shared_ptr<int, std::_S_single>;
+ bool test __attribute__ ((unused)) = false;
+ constexpr auto mo = std::memory_order_seq_cst;
+ const test_type p;
+ test = std::atomic_is_lock_free(&p);
+ test_type p2 = std::atomic_load(&p);
+ test_type p3 = std::atomic_load_explicit(&p, mo);
+ std::atomic_store(&p2, p);
+ std::atomic_store_explicit(&p2, p, mo);
+ test_type p4 = std::atomic_exchange(&p2, p);
+ p4 = std::atomic_exchange_explicit(&p2, p, mo);
+ test = std::atomic_compare_exchange_weak(&p2, &p3, p);
+ test = std::atomic_compare_exchange_strong(&p2, &p3, p);
+ test = std::atomic_compare_exchange_weak_explicit(&p2, &p3, p, mo, mo);
+ test = std::atomic_compare_exchange_strong_explicit(&p2, &p3, p, mo, mo);
+}
diff --git a/libstdc++-v3/testsuite/20_util/shared_ptr/atomic/3.cc b/libstdc++-v3/testsuite/20_util/shared_ptr/atomic/3.cc
new file mode 100644
index 0000000..f964806
--- /dev/null
+++ b/libstdc++-v3/testsuite/20_util/shared_ptr/atomic/3.cc
@@ -0,0 +1,53 @@
+// { dg-do run { target *-*-freebsd* *-*-dragonfly* *-*-netbsd* *-*-linux* *-*-gnu* *-*-solaris* *-*-cygwin *-*-darwin* powerpc-ibm-aix* } }
+// { dg-options " -std=gnu++11 -pthread" { target *-*-freebsd* *-*-dragonfly* *-*-netbsd* *-*-linux* *-*-gnu* powerpc-ibm-aix* } }
+// { dg-options " -std=gnu++11 -pthreads" { target *-*-solaris* } }
+// { dg-options " -std=gnu++11 " { target *-*-cygwin *-*-darwin* } }
+// { dg-require-cstdint "" }
+// { dg-require-gthreads "" }
+
+// Copyright (C) 2014 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/>.
+
+#include <thread>
+#include <memory>
+#include <testsuite_hooks.h>
+
+struct leaddock
+{
+ ~leaddock();
+};
+
+std::shared_ptr<leaddock> global;
+
+leaddock::~leaddock()
+{
+ // If this destructor is called "inside" an atomic operation on global it
+ // will deadlock, so this checks that the atomic_store is done atomically.
+ auto copy = std::atomic_load(&global);
+ VERIFY( !copy );
+}
+
+void f()
+{
+ std::atomic_store(&global, std::make_shared<leaddock>());
+ std::atomic_store(&global, {});
+}
+
+int main()
+{
+ std::thread{ f }.join();
+}
^ permalink raw reply [flat|nested] 2+ messages in thread
end of thread, other threads:[~2014-11-12 23:55 UTC | newest]
Thread overview: 2+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2014-10-17 18:28 [patch] libstdc++/57250 shared_ptr atomic operations Jonathan Wakely
2014-11-13 0:10 ` Jonathan Wakely
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).