Re: Proposed patch to skip the last atomic decrements in _Sp_counted_base::_M_release

[Maged Michael <maged.michael@gmail.com>]

The attached patch was scrubbed. Including it inline.

diff --git a/libstdc++-v3/include/bits/shared_ptr_base.h
b/libstdc++-v3/include/bits/shared_ptr_base.h
index 368b2d7379a..c675b0f6916 100644
--- a/libstdc++-v3/include/bits/shared_ptr_base.h
+++ b/libstdc++-v3/include/bits/shared_ptr_base.h
@@ -122,80 +122,126 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
     class _Sp_counted_base
     : public _Mutex_base<_Lp>
     {
     public:
       _Sp_counted_base() noexcept
       : _M_use_count(1), _M_weak_count(1) { }

       virtual
       ~_Sp_counted_base() noexcept
       { }

       // Called when _M_use_count drops to zero, to release the resources
       // managed by *this.
       virtual void
       _M_dispose() noexcept = 0;

       // Called when _M_weak_count drops to zero.
       virtual void
       _M_destroy() noexcept
       { delete this; }

       virtual void*
       _M_get_deleter(const std::type_info&) noexcept = 0;

       void
       _M_add_ref_copy()
       { __gnu_cxx::__atomic_add_dispatch(&_M_use_count, 1); }

       void
       _M_add_ref_lock()
       {
  if (!_M_add_ref_lock_nothrow())
   __throw_bad_weak_ptr();
       }

       bool
       _M_add_ref_lock_nothrow() noexcept;

       void
       _M_release() noexcept
+      {
+        if (!__LP64__ || sizeof(_Atomic_word) != 4 || sizeof(long long) !=
8)
+          {
+            _M_release_orig();
+            return;
+          }
+        _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(&_M_use_count);
+        _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(&_M_weak_count);
+        if ((__atomic_load_n((long long*)(&_M_use_count), __ATOMIC_ACQUIRE)
+            == 0x100000001))
+          {
+            _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(&_M_use_count);
+            _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(&_M_weak_count);
+            _M_dispose();
+            _M_destroy();
+          }
+        else
+          {
+            if ((__gnu_cxx::__exchange_and_add(&_M_use_count, -1) == 1))
+              {
+                _M_release_last_use();
+              }
+          }
+      }
+
+      void
+      __attribute__ ((noinline))
+      _M_release_last_use() noexcept
+      {
+        _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(&_M_use_count);
+        _M_dispose();
+        if (_Mutex_base<_Lp>::_S_need_barriers)
+          {
+            __atomic_thread_fence (__ATOMIC_ACQ_REL);
+          }
+        _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(&_M_weak_count);
+        if (__gnu_cxx::__exchange_and_add_dispatch(&_M_weak_count,
+                                                   -1) == 1)
+          {
+            _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(&_M_weak_count);
+            _M_destroy();
+          }
+      }
+
+      void
+      _M_release_orig() noexcept
       {
         // Be race-detector-friendly.  For more info see bits/c++config.
         _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(&_M_use_count);
  if (__gnu_cxx::__exchange_and_add_dispatch(&_M_use_count, -1) == 1)
   {
             _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(&_M_use_count);
     _M_dispose();
     // There must be a memory barrier between dispose() and destroy()
     // to ensure that the effects of dispose() are observed in the
     // thread that runs destroy().
     // See http://gcc.gnu.org/ml/libstdc++/2005-11/msg00136.html
     if (_Mutex_base<_Lp>::_S_need_barriers)
       {
  __atomic_thread_fence (__ATOMIC_ACQ_REL);
       }

             // Be race-detector-friendly.  For more info see
bits/c++config.
             _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(&_M_weak_count);
     if (__gnu_cxx::__exchange_and_add_dispatch(&_M_weak_count,
        -1) == 1)
               {
                 _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(&_M_weak_count);
         _M_destroy();
               }
   }
       }

       void
       _M_weak_add_ref() noexcept
       { __gnu_cxx::__atomic_add_dispatch(&_M_weak_count, 1); }

       void
       _M_weak_release() noexcept
       {
         // Be race-detector-friendly. For more info see bits/c++config.
         _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(&_M_weak_count);
  if (__gnu_cxx::__exchange_and_add_dispatch(&_M_weak_count, -1) == 1)
   {
             _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(&_M_weak_count);
     if (_Mutex_base<_Lp>::_S_need_barriers)