passenger 6.0.14 → 6.0.27

data/src/cxx_supportlib/vendor-modified/boost/unordered/detail/foa/reentrancy_check.hpp

@@ -0,0 +1,138 @@
+/* Copyright 2023 Joaquin M Lopez Munoz.
+ * Distributed under the Boost Software License, Version 1.0.
+ * (See accompanying file LICENSE_1_0.txt or copy at
+ * http://www.boost.org/LICENSE_1_0.txt)
+ *
+ * See https://www.boost.org/libs/unordered for library home page.
+ */
+
+#ifndef BOOST_UNORDERED_DETAIL_FOA_REENTRANCY_CHECK_HPP
+#define BOOST_UNORDERED_DETAIL_FOA_REENTRANCY_CHECK_HPP
+
+#include <boost/assert.hpp>
+#include <utility>
+
+#if !defined(BOOST_UNORDERED_DISABLE_REENTRANCY_CHECK)&& \
+    !defined(BOOST_ASSERT_IS_VOID)
+#define BOOST_UNORDERED_REENTRANCY_CHECK
+#endif
+
+namespace boost{
+namespace unordered{
+namespace detail{
+namespace foa{
+
+#if defined(BOOST_UNORDERED_REENTRANCY_CHECK)
+
+class entry_trace
+{
+public:
+  entry_trace(const void* px_):px{px_}
+  {
+    if(px){
+      BOOST_ASSERT_MSG(!find(px),"reentrancy not allowed");
+      header()=this;
+    }
+  }
+
+  /* not used but VS in pre-C++17 mode needs to see it for RVO */
+  entry_trace(const entry_trace&);
+
+  ~entry_trace(){clear();}
+
+  void clear()
+  {
+    if(px){
+      header()=next;
+      px=nullptr;
+    }
+  }
+  
+private:
+  static entry_trace*& header()
+  {
+    thread_local entry_trace *pe=nullptr;
+    return pe;
+  }
+
+  static bool find(const void* px)
+  {
+    for(auto pe=header();pe;pe=pe->next){
+      if(pe->px==px)return true;
+    }
+    return false;
+  }
+
+  const void  *px;
+  entry_trace *next=header();
+};
+
+template<typename LockGuard>
+struct reentrancy_checked
+{
+  template<typename... Args>
+  reentrancy_checked(const void* px,Args&&... args):
+    tr{px},lck{std::forward<Args>(args)...}{}
+
+  void unlock()
+  {
+    lck.unlock();
+    tr.clear();
+  }
+
+  entry_trace tr;
+  LockGuard   lck;
+};
+
+template<typename LockGuard>
+struct reentrancy_bichecked
+{
+  template<typename... Args>
+  reentrancy_bichecked(const void* px,const void* py,Args&&... args):
+    tr1{px},tr2{py!=px?py:nullptr},lck{std::forward<Args>(args)...}{}
+
+  void unlock()
+  {
+    lck.unlock();
+    tr2.clear();
+    tr1.clear();
+  }
+
+  entry_trace tr1,tr2;
+  LockGuard   lck;
+};
+
+#else
+
+template<typename LockGuard>
+struct reentrancy_checked
+{
+  template<typename... Args>
+  reentrancy_checked(const void*,Args&&... args):
+    lck{std::forward<Args>(args)...}{}
+
+  void unlock(){lck.unlock();}
+
+  LockGuard lck;
+};
+
+template<typename LockGuard>
+struct reentrancy_bichecked
+{
+  template<typename... Args>
+  reentrancy_bichecked(const void*,const void*,Args&&... args):
+    lck{std::forward<Args>(args)...}{}
+
+  void unlock(){lck.unlock();}
+
+  LockGuard lck;
+};
+
+#endif
+
+} /* namespace foa */
+} /* namespace detail */
+} /* namespace unordered */
+} /* namespace boost */
+
+#endif

data/src/cxx_supportlib/vendor-modified/boost/unordered/detail/foa/restore_wshadow.hpp

@@ -0,0 +1,11 @@
+/* Copyright 2023 Joaquin M Lopez Munoz.
+ * Distributed under the Boost Software License, Version 1.0.
+ * (See accompanying file LICENSE_1_0.txt or copy at
+ * http://www.boost.org/LICENSE_1_0.txt)
+ *
+ * See https://www.boost.org/libs/unordered for library home page.
+ */
+
+#define BOOST_UNORDERED_DETAIL_RESTORE_WSHADOW
+#include <boost/unordered/detail/foa/ignore_wshadow.hpp>
+#undef BOOST_UNORDERED_DETAIL_RESTORE_WSHADOW

data/src/cxx_supportlib/vendor-modified/boost/unordered/detail/foa/rw_spinlock.hpp

@@ -0,0 +1,179 @@
+#ifndef BOOST_UNORDERED_DETAIL_FOA_RW_SPINLOCK_HPP_INCLUDED
+#define BOOST_UNORDERED_DETAIL_FOA_RW_SPINLOCK_HPP_INCLUDED
+
+// Copyright 2023 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/core/yield_primitives.hpp>
+#include <atomic>
+#include <cstdint>
+
+namespace boost{
+namespace unordered{
+namespace detail{
+namespace foa{
+
+class rw_spinlock
+{
+private:
+
+    // bit 31: locked exclusive
+    // bit 30: writer pending
+    // bit 29..0: reader lock count
+
+    static constexpr std::uint32_t locked_exclusive_mask = 1u << 31; // 0x8000'0000
+    static constexpr std::uint32_t writer_pending_mask = 1u << 30; // 0x4000'0000
+    static constexpr std::uint32_t reader_lock_count_mask = writer_pending_mask - 1; // 0x3FFF'FFFF
+
+    std::atomic<std::uint32_t> state_ = {};
+
+private:
+
+    // Effects: Provides a hint to the implementation that the current thread
+    //          has been unable to make progress for k+1 iterations.
+
+    static void yield( unsigned k ) noexcept
+    {
+        unsigned const sleep_every = 1024; // see below
+
+        k %= sleep_every;
+
+        if( k < 5 )
+        {
+            // Intel recommendation from the Optimization Reference Manual
+            // Exponentially increase number of PAUSE instructions each
+            // iteration until reaching a maximum which is approximately
+            // one timeslice long (2^4 == 16 in our case)
+
+            unsigned const pause_count = 1u << k;
+
+            for( unsigned i = 0; i < pause_count; ++i )
+            {
+                boost::core::sp_thread_pause();
+            }
+        }
+        else if( k < sleep_every - 1 )
+        {
+            // Once the maximum number of PAUSE instructions is reached,
+            // we switch to yielding the timeslice immediately
+
+            boost::core::sp_thread_yield();
+        }
+        else
+        {
+            // After `sleep_every` iterations of no progress, we sleep,
+            // to avoid a deadlock if a lower priority thread has the lock
+
+            boost::core::sp_thread_sleep();
+        }
+    }
+
+public:
+
+    bool try_lock_shared() noexcept
+    {
+        std::uint32_t st = state_.load( std::memory_order_relaxed );
+
+        if( st >= reader_lock_count_mask )
+        {
+            // either bit 31 set, bit 30 set, or reader count is max
+            return false;
+        }
+
+        std::uint32_t newst = st + 1;
+        return state_.compare_exchange_strong( st, newst, std::memory_order_acquire, std::memory_order_relaxed );
+    }
+
+    void lock_shared() noexcept
+    {
+        for( unsigned k = 0; ; ++k )
+        {
+            std::uint32_t st = state_.load( std::memory_order_relaxed );
+
+            if( st < reader_lock_count_mask )
+            {
+                std::uint32_t newst = st + 1;
+                if( state_.compare_exchange_weak( st, newst, std::memory_order_acquire, std::memory_order_relaxed ) ) return;
+            }
+
+            yield( k );
+        }
+    }
+
+    void unlock_shared() noexcept
+    {
+        // pre: locked shared, not locked exclusive
+
+        state_.fetch_sub( 1, std::memory_order_release );
+
+        // if the writer pending bit is set, there's a writer waiting
+        // let it acquire the lock; it will clear the bit on unlock
+    }
+
+    bool try_lock() noexcept
+    {
+        std::uint32_t st = state_.load( std::memory_order_relaxed );
+
+        if( st & locked_exclusive_mask )
+        {
+            // locked exclusive
+            return false;
+        }
+
+        if( st & reader_lock_count_mask )
+        {
+            // locked shared
+            return false;
+        }
+
+        std::uint32_t newst = locked_exclusive_mask;
+        return state_.compare_exchange_strong( st, newst, std::memory_order_acquire, std::memory_order_relaxed );
+    }
+
+    void lock() noexcept
+    {
+        for( unsigned k = 0; ; ++k )
+        {
+            std::uint32_t st = state_.load( std::memory_order_relaxed );
+
+            if( st & locked_exclusive_mask )
+            {
+                // locked exclusive, spin
+            }
+            else if( ( st & reader_lock_count_mask ) == 0 )
+            {
+                // not locked exclusive, not locked shared, try to lock
+
+                std::uint32_t newst = locked_exclusive_mask;
+                if( state_.compare_exchange_weak( st, newst, std::memory_order_acquire, std::memory_order_relaxed ) ) return;
+            }
+            else if( st & writer_pending_mask )
+            {
+                // writer pending bit already set, nothing to do
+            }
+            else
+            {
+                // locked shared, set writer pending bit
+
+                std::uint32_t newst = st | writer_pending_mask;
+                state_.compare_exchange_weak( st, newst, std::memory_order_relaxed, std::memory_order_relaxed );
+            }
+
+            yield( k );
+        }
+    }
+
+    void unlock() noexcept
+    {
+        // pre: locked exclusive, not locked shared
+        state_.store( 0, std::memory_order_release );
+    }
+};
+
+} /* namespace foa */
+} /* namespace detail */
+} /* namespace unordered */
+} /* namespace boost */
+
+#endif // BOOST_UNORDERED_DETAIL_FOA_RW_SPINLOCK_HPP_INCLUDED