passenger 6.0.23 → 6.0.24

data/src/cxx_supportlib/vendor-modified/boost/move/detail/launder.hpp

@@ -0,0 +1,53 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2014-2015. 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 http://www.boost.org/libs/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+#ifndef BOOST_MOVE_DETAIL_LAUNDER_HPP
+#define BOOST_MOVE_DETAIL_LAUNDER_HPP
+
+#ifndef BOOST_CONFIG_HPP
+#  include <boost/config.hpp>
+#endif
+
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+#  pragma once
+#endif
+
+#include <boost/move/detail/workaround.hpp>
+
+namespace boost {
+namespace move_detail {
+
+#if defined(BOOST_MOVE_HAS_BUILTIN_LAUNDER)
+
+template<class T>
+BOOST_MOVE_FORCEINLINE T* launder(T* p)
+{
+    return __builtin_launder( p );
+}
+
+#else
+
+template<class T>
+BOOST_MOVE_FORCEINLINE T* launder(T* p)
+{
+    return p;
+}
+
+#endif
+
+template<class T>
+BOOST_MOVE_FORCEINLINE T launder_cast(const volatile void* p)
+{
+   return (launder)((T)p);
+}
+
+}  //namespace move_detail {
+}  //namespace boost {
+
+#endif   //#ifndef BOOST_MOVE_DETAIL_LAUNDER_HPP

data/src/cxx_supportlib/vendor-modified/boost/move/detail/type_traits.hpp

@@ -1197,12 +1197,20 @@ struct aligned_struct;
 template <> struct aligned_struct<1> { char data; };
 template <> struct aligned_struct<2> { short data; };
 template <> struct aligned_struct<4> { int data; };
-template <> struct aligned_struct<8> { double data; };
+//8 byte alignment does not propely work in x86 if attribute is not used.
+//If a user declares a variable with 8 byte alignment, such as a double
+//the compiler will not realign the stack.
+// 
+//If _declspec(align) is used MSVC will realign the stack.
+//
+//Disabled specialization
+//template <> struct aligned_struct<8> { double data; };
 
 #define BOOST_MOVE_ALIGNED_STRUCT(x) \
   template <> struct aligned_struct<x> { \
     __declspec(align(x)) char data; \
   }
+BOOST_MOVE_ALIGNED_STRUCT(8);
 BOOST_MOVE_ALIGNED_STRUCT(16);
 BOOST_MOVE_ALIGNED_STRUCT(32);
 BOOST_MOVE_ALIGNED_STRUCT(64);

data/src/cxx_supportlib/vendor-modified/boost/move/detail/workaround.hpp

@@ -147,5 +147,10 @@ template<unsigned> struct static_assert_test {};
 #define BOOST_MOVE_INTRINSIC_CAST BOOST_MOVE_FORCEINLINE
 #endif
 
-#endif   //#ifndef BOOST_MOVE_DETAIL_WORKAROUND_HPP
+#if defined(__has_builtin)
+#if __has_builtin(__builtin_launder)
+   #define BOOST_MOVE_HAS_BUILTIN_LAUNDER
+#endif
+#endif
 
+#endif   //#ifndef BOOST_MOVE_DETAIL_WORKAROUND_HPP

data/src/cxx_supportlib/vendor-modified/boost/mp11/version.hpp

@@ -11,6 +11,6 @@
 // Same format as BOOST_VERSION:
 //   major * 100000 + minor * 100 + patch
 
-#define BOOST_MP11_VERSION 108500
+#define BOOST_MP11_VERSION 108600
 
 #endif // #ifndef BOOST_MP11_VERSION_HPP_INCLUDED

data/src/cxx_supportlib/vendor-modified/boost/mpl/aux_/integral_wrapper.hpp

@@ -56,7 +56,8 @@ struct AUX_WRAPPER_NAME
 // have to #ifdef here: some compilers don't like the 'N + 1' form (MSVC),
 // while some other don't like 'value + 1' (Borland), and some don't like
 // either
-#if BOOST_WORKAROUND(__EDG_VERSION__, <= 243)
+#if BOOST_WORKAROUND(__EDG_VERSION__, <= 243) \
+    || __cplusplus >= 201103L
  private:
     BOOST_STATIC_CONSTANT(AUX_WRAPPER_VALUE_TYPE, next_value = BOOST_MPL_AUX_STATIC_CAST(AUX_WRAPPER_VALUE_TYPE, (N + 1)));
     BOOST_STATIC_CONSTANT(AUX_WRAPPER_VALUE_TYPE, prior_value = BOOST_MPL_AUX_STATIC_CAST(AUX_WRAPPER_VALUE_TYPE, (N - 1)));

data/src/cxx_supportlib/vendor-modified/boost/predef/version.h

@@ -10,6 +10,6 @@ http://www.boost.org/LICENSE_1_0.txt)
 
 #include <boost/predef/version_number.h>
 
-#define BOOST_PREDEF_VERSION BOOST_VERSION_NUMBER(1,15,0)
+#define BOOST_PREDEF_VERSION BOOST_VERSION_NUMBER(1,15,1)
 
 #endif

data/src/cxx_supportlib/vendor-modified/boost/smart_ptr/detail/requires_cxx11.hpp

@@ -16,7 +16,7 @@
     defined(BOOST_NO_CXX11_NULLPTR) || \
     defined(BOOST_NO_CXX11_SMART_PTR)
 
-BOOST_PRAGMA_MESSAGE("C++03 support was deprecated in Boost.SmartPtr 1.82 and will be removed in Boost.SmartPtr 1.86.")
+BOOST_PRAGMA_MESSAGE("C++03 support was deprecated in Boost.SmartPtr 1.82 and will be removed in Boost.SmartPtr 1.87.")
 
 #endif
 

data/src/cxx_supportlib/vendor-modified/boost/smart_ptr/detail/sp_has_gcc_intrinsics.hpp

@@ -17,8 +17,11 @@
 // Defines the BOOST_SP_HAS_GCC_INTRINSICS macro if the __atomic_*
 // intrinsics are available.
 
+// Libraries (e.g. Kokkos) sometimes define the __ATOMIC_RELAXED macros,
+// leading to errors under MSVC (https://github.com/boostorg/smart_ptr/pull/112)
 
-#if defined( __ATOMIC_RELAXED ) && defined( __ATOMIC_ACQUIRE ) && defined( __ATOMIC_RELEASE ) && defined( __ATOMIC_ACQ_REL )
+#if defined( __ATOMIC_RELAXED ) && defined( __ATOMIC_ACQUIRE ) && defined( __ATOMIC_RELEASE ) && defined( __ATOMIC_ACQ_REL ) \
+    && !( defined(_MSC_VER) && !defined(__clang__) )
 
 # define BOOST_SP_HAS_GCC_INTRINSICS
 

data/src/cxx_supportlib/vendor-modified/boost/system/detail/generic_category_message.hpp

@@ -39,7 +39,19 @@ inline char const * strerror_r_helper( int r, char const * buffer ) noexcept
 
 inline char const * generic_error_category_message( int ev, char * buffer, std::size_t len ) noexcept
 {
-    return strerror_r_helper( strerror_r( ev, buffer, len ), buffer );
+    if( buffer != nullptr )
+    {
+        return strerror_r_helper( strerror_r( ev, buffer, len ), buffer );
+    }
+    else
+    {
+        // strerror_r requires non-null buffer pointer
+
+        char tmp[ 1 ] = {};
+        char const* r = strerror_r_helper( strerror_r( ev, tmp, 0 ), buffer );
+
+        return r == tmp? nullptr: r;
+    }
 }
 
 inline std::string generic_error_category_message( int ev )

data/src/cxx_supportlib/vendor-modified/boost/unordered/concurrent_flat_map.hpp

@@ -1,7 +1,7 @@
 /* Fast open-addressing concurrent hashmap.
  *
  * Copyright 2023 Christian Mazakas.
- * Copyright 2023 Joaquin M Lopez Munoz.
+ * Copyright 2023-2024 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)
@@ -75,6 +75,10 @@ namespace boost {
         typename boost::allocator_const_pointer<allocator_type>::type;
       static constexpr size_type bulk_visit_size = table_type::bulk_visit_size;
 
+#if defined(BOOST_UNORDERED_ENABLE_STATS)
+      using stats = typename table_type::stats;
+#endif
+
       concurrent_flat_map()
           : concurrent_flat_map(detail::foa::default_bucket_count)
       {
@@ -714,6 +718,14 @@ namespace boost {
       void rehash(size_type n) { table_.rehash(n); }
       void reserve(size_type n) { table_.reserve(n); }
 
+#if defined(BOOST_UNORDERED_ENABLE_STATS)
+      /// Stats
+      ///
+      stats get_stats() const { return table_.get_stats(); }
+
+      void reset_stats() noexcept { table_.reset_stats(); }
+#endif
+
       /// Observers
       ///
       allocator_type get_allocator() const noexcept

data/src/cxx_supportlib/vendor-modified/boost/unordered/concurrent_flat_map_fwd.hpp

@@ -1,6 +1,7 @@
 /* Fast open-addressing concurrent hashmap.
  *
  * Copyright 2023 Christian Mazakas.
+ * Copyright 2024 Braden Ganetsky.
  * 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)
@@ -11,11 +12,16 @@
 #ifndef BOOST_UNORDERED_CONCURRENT_FLAT_MAP_FWD_HPP
 #define BOOST_UNORDERED_CONCURRENT_FLAT_MAP_FWD_HPP
 
+#include <boost/config.hpp>
 #include <boost/container_hash/hash_fwd.hpp>
 
 #include <functional>
 #include <memory>
 
+#ifndef BOOST_NO_CXX17_HDR_MEMORY_RESOURCE
+#include <memory_resource>
+#endif
+
 namespace boost {
   namespace unordered {
 
@@ -43,6 +49,15 @@ namespace boost {
     typename concurrent_flat_map<K, T, H, P, A>::size_type erase_if(
       concurrent_flat_map<K, T, H, P, A>& c, Predicate pred);
 
+#ifndef BOOST_NO_CXX17_HDR_MEMORY_RESOURCE
+    namespace pmr {
+      template <class Key, class T, class Hash = boost::hash<Key>,
+        class Pred = std::equal_to<Key> >
+      using concurrent_flat_map = boost::unordered::concurrent_flat_map<Key, T,
+        Hash, Pred, std::pmr::polymorphic_allocator<std::pair<Key const, T> > >;
+    } // namespace pmr
+#endif
+
   } // namespace unordered
 
   using boost::unordered::concurrent_flat_map;

data/src/cxx_supportlib/vendor-modified/boost/unordered/concurrent_flat_set.hpp

@@ -1,7 +1,7 @@
 /* Fast open-addressing concurrent hashset.
  *
  * Copyright 2023 Christian Mazakas.
- * Copyright 2023 Joaquin M Lopez Munoz.
+ * Copyright 2023-2024 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)
@@ -72,6 +72,10 @@ namespace boost {
         typename boost::allocator_const_pointer<allocator_type>::type;
       static constexpr size_type bulk_visit_size = table_type::bulk_visit_size;
 
+#if defined(BOOST_UNORDERED_ENABLE_STATS)
+      using stats = typename table_type::stats;
+#endif
+
       concurrent_flat_set()
           : concurrent_flat_set(detail::foa::default_bucket_count)
       {
@@ -582,6 +586,14 @@ namespace boost {
       void rehash(size_type n) { table_.rehash(n); }
       void reserve(size_type n) { table_.reserve(n); }
 
+#if defined(BOOST_UNORDERED_ENABLE_STATS)
+      /// Stats
+      ///
+      stats get_stats() const { return table_.get_stats(); }
+
+      void reset_stats() noexcept { table_.reset_stats(); }
+#endif
+
       /// Observers
       ///
       allocator_type get_allocator() const noexcept

data/src/cxx_supportlib/vendor-modified/boost/unordered/concurrent_flat_set_fwd.hpp

@@ -2,6 +2,7 @@
  *
  * Copyright 2023 Christian Mazakas.
  * Copyright 2023 Joaquin M Lopez Munoz.
+ * Copyright 2024 Braden Ganetsky.
  * 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)
@@ -12,11 +13,16 @@
 #ifndef BOOST_UNORDERED_CONCURRENT_FLAT_SET_FWD_HPP
 #define BOOST_UNORDERED_CONCURRENT_FLAT_SET_FWD_HPP
 
+#include <boost/config.hpp>
 #include <boost/container_hash/hash_fwd.hpp>
 
 #include <functional>
 #include <memory>
 
+#ifndef BOOST_NO_CXX17_HDR_MEMORY_RESOURCE
+#include <memory_resource>
+#endif
+
 namespace boost {
   namespace unordered {
 
@@ -44,6 +50,15 @@ namespace boost {
     typename concurrent_flat_set<K, H, P, A>::size_type erase_if(
       concurrent_flat_set<K, H, P, A>& c, Predicate pred);
 
+#ifndef BOOST_NO_CXX17_HDR_MEMORY_RESOURCE
+    namespace pmr {
+      template <class Key, class Hash = boost::hash<Key>,
+        class Pred = std::equal_to<Key> >
+      using concurrent_flat_set = boost::unordered::concurrent_flat_set<Key,
+        Hash, Pred, std::pmr::polymorphic_allocator<Key> >;
+    } // namespace pmr
+#endif
+
   } // namespace unordered
 
   using boost::unordered::concurrent_flat_set;

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

@@ -659,12 +659,7 @@ namespace boost {
           std::swap(buckets, other.buckets);
           std::swap(groups, other.groups);
 
-          bool b = boost::allocator_propagate_on_container_swap<
-            allocator_type>::type::value;
-          if (b) {
-            boost::core::invoke_swap(
-              get_node_allocator(), other.get_node_allocator());
-          }
+          swap_allocator_if_pocs(other);
         }
 
         node_allocator_type const& get_node_allocator() const
@@ -876,6 +871,27 @@ namespace boost {
           pbg->prev->next = pbg->next;
           pbg->prev = pbg->next = group_pointer();
         }
+
+        void swap_allocator_if_pocs(grouped_bucket_array& other)
+        {
+          using allocator_pocs =
+            typename boost::allocator_propagate_on_container_swap<
+              allocator_type>::type;
+          swap_allocator_if_pocs(
+            other, std::integral_constant<bool, allocator_pocs::value>());
+        }
+
+        void swap_allocator_if_pocs(
+          grouped_bucket_array& other, std::true_type /* propagate */)
+        {
+          boost::core::invoke_swap(
+            get_node_allocator(), other.get_node_allocator());
+        }
+
+        void swap_allocator_if_pocs(
+          grouped_bucket_array&, std::false_type /* don't propagate */)
+        {
+        }
       };
     } // namespace detail
   } // namespace unordered

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

@@ -469,6 +469,10 @@ public:
   using size_type=typename super::size_type;
   static constexpr std::size_t bulk_visit_size=16;
 
+#if defined(BOOST_UNORDERED_ENABLE_STATS)
+  using stats=typename super::stats;
+#endif
+
 private:
   template<typename Value,typename T>
   using enable_if_is_value_type=typename std::enable_if<
@@ -510,6 +514,7 @@ public:
     x.arrays=ah.release();
     x.size_ctrl.ml=x.initial_max_load();
     x.size_ctrl.size=0;
+    BOOST_UNORDERED_SWAP_STATS(this->cstats,x.cstats);
   }
 
   concurrent_table(compatible_nonconcurrent_table&& x):
@@ -965,6 +970,13 @@ public:
     super::reserve(n);
   }
 
+#if defined(BOOST_UNORDERED_ENABLE_STATS)
+  /* already thread safe */
+
+  using super::get_stats;
+  using super::reset_stats;
+#endif
+
   template<typename Predicate>
   friend std::size_t erase_if(concurrent_table& x,Predicate&& pr)
   {
@@ -1186,6 +1198,7 @@ private:
     GroupAccessMode access_mode,
     const Key& x,std::size_t pos0,std::size_t hash,F&& f)const
   {    
+    BOOST_UNORDERED_STATS_COUNTER(num_cmps);
     prober pb(pos0);
     do{
       auto pos=pb.get();
@@ -1197,19 +1210,27 @@ private:
         auto lck=access(access_mode,pos);
         do{
           auto n=unchecked_countr_zero(mask);
-          if(BOOST_LIKELY(
-            pg->is_occupied(n)&&bool(this->pred()(x,this->key_from(p[n]))))){
-            f(pg,n,p+n);
-            return 1;
+          if(BOOST_LIKELY(pg->is_occupied(n))){
+            BOOST_UNORDERED_INCREMENT_STATS_COUNTER(num_cmps);
+            if(BOOST_LIKELY(bool(this->pred()(x,this->key_from(p[n]))))){
+              f(pg,n,p+n);
+              BOOST_UNORDERED_ADD_STATS(
+                this->cstats.successful_lookup,(pb.length(),num_cmps));
+              return 1;
+            }
           }
           mask&=mask-1;
         }while(mask);
       }
       if(BOOST_LIKELY(pg->is_not_overflowed(hash))){
+        BOOST_UNORDERED_ADD_STATS(
+          this->cstats.unsuccessful_lookup,(pb.length(),num_cmps));
         return 0;
       }
     }
     while(BOOST_LIKELY(pb.next(this->arrays.groups_size_mask)));
+    BOOST_UNORDERED_ADD_STATS(
+      this->cstats.unsuccessful_lookup,(pb.length(),num_cmps));
     return 0;
   }
 
@@ -1244,6 +1265,7 @@ private:
 
     it=first;
     for(auto i=m;i--;++it){
+      BOOST_UNORDERED_STATS_COUNTER(num_cmps);
       auto          pos=positions[i];
       prober        pb(pos);
       auto          pg=this->arrays.groups()+pos;
@@ -1256,12 +1278,15 @@ private:
           auto lck=access(access_mode,pos);
           do{
             auto n=unchecked_countr_zero(mask);
-            if(BOOST_LIKELY(
-              pg->is_occupied(n)&&
-              bool(this->pred()(*it,this->key_from(p[n]))))){
-              f(cast_for(access_mode,type_policy::value_from(p[n])));
-              ++res;
-              goto next_key;
+            if(BOOST_LIKELY(pg->is_occupied(n))){
+              BOOST_UNORDERED_INCREMENT_STATS_COUNTER(num_cmps);
+              if(bool(this->pred()(*it,this->key_from(p[n])))){
+                f(cast_for(access_mode,type_policy::value_from(p[n])));
+                ++res;
+                BOOST_UNORDERED_ADD_STATS(
+                  this->cstats.successful_lookup,(pb.length(),num_cmps));
+                goto next_key;
+              }
             }
             mask&=mask-1;
           }while(mask);
@@ -1270,6 +1295,8 @@ private:
         do{
           if(BOOST_LIKELY(pg->is_not_overflowed(hashes[i]))||
              BOOST_UNLIKELY(!pb.next(this->arrays.groups_size_mask))){
+            BOOST_UNORDERED_ADD_STATS(
+              this->cstats.unsuccessful_lookup,(pb.length(),num_cmps));
             goto next_key;
           }
           pos=pb.get();
@@ -1490,6 +1517,7 @@ private:
             this->construct_element(p,std::forward<Args>(args)...);
             rslot.commit();
             rsize.commit();
+            BOOST_UNORDERED_ADD_STATS(this->cstats.insertion,(pb.length()));
             return 1;
           }
           pg->mark_overflow(hash);