passenger 6.0.22 → 6.0.24

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

@@ -40,6 +40,10 @@
 #include <type_traits>
 #include <utility>
 
+#if defined(BOOST_UNORDERED_ENABLE_STATS)
+#include <boost/unordered/detail/foa/cumulative_stats.hpp>
+#endif
+
 #if !defined(BOOST_UNORDERED_DISABLE_SSE2)
 #if defined(BOOST_UNORDERED_ENABLE_SSE2)|| \
     defined(__SSE2__)|| \
@@ -864,6 +868,7 @@ struct pow2_quadratic_prober
   pow2_quadratic_prober(std::size_t pos_):pos{pos_}{}
 
   inline std::size_t get()const{return pos;}
+  inline std::size_t length()const{return step+1;}
 
   /* next returns false when the whole array has been traversed, which ends
    * probing (in practice, full-table probing will only happen with very small
@@ -1125,6 +1130,54 @@ struct table_arrays
   value_type_pointer elements_;
 };
 
+#if defined(BOOST_UNORDERED_ENABLE_STATS)
+/* stats support */
+
+struct table_core_cumulative_stats
+{
+  concurrent_cumulative_stats<1> insertion;
+  concurrent_cumulative_stats<2> successful_lookup,
+                                 unsuccessful_lookup;
+};
+
+struct table_core_insertion_stats
+{
+  std::size_t            count;
+  sequence_stats_summary probe_length;
+};
+
+struct table_core_lookup_stats
+{
+  std::size_t            count;
+  sequence_stats_summary probe_length;
+  sequence_stats_summary num_comparisons;
+};
+
+struct table_core_stats
+{
+  table_core_insertion_stats insertion;
+  table_core_lookup_stats    successful_lookup,
+                             unsuccessful_lookup;
+};
+
+#define BOOST_UNORDERED_ADD_STATS(stats,args) stats.add args
+#define BOOST_UNORDERED_SWAP_STATS(stats1,stats2) std::swap(stats1,stats2)
+#define BOOST_UNORDERED_COPY_STATS(stats1,stats2) stats1=stats2
+#define BOOST_UNORDERED_RESET_STATS_OF(x) x.reset_stats()
+#define BOOST_UNORDERED_STATS_COUNTER(name) std::size_t name=0
+#define BOOST_UNORDERED_INCREMENT_STATS_COUNTER(name) ++name
+
+#else
+
+#define BOOST_UNORDERED_ADD_STATS(stats,args) ((void)0)
+#define BOOST_UNORDERED_SWAP_STATS(stats1,stats2) ((void)0)
+#define BOOST_UNORDERED_COPY_STATS(stats1,stats2) ((void)0)
+#define BOOST_UNORDERED_RESET_STATS_OF(x) ((void)0)
+#define BOOST_UNORDERED_STATS_COUNTER(name) ((void)0)
+#define BOOST_UNORDERED_INCREMENT_STATS_COUNTER(name) ((void)0)
+
+#endif
+
 struct if_constexpr_void_else{void operator()()const{}};
 
 template<bool B,typename F,typename G=if_constexpr_void_else>
@@ -1395,6 +1448,11 @@ public:
   using locator=table_locator<group_type,element_type>;
   using arrays_holder_type=arrays_holder<arrays_type,Allocator>;
 
+#if defined(BOOST_UNORDERED_ENABLE_STATS)
+  using cumulative_stats=table_core_cumulative_stats;
+  using stats=table_core_stats;
+#endif
+
   table_core(
     std::size_t n=default_bucket_count,const Hash& h_=Hash(),
     const Pred& pred_=Pred(),const Allocator& al_=Allocator()):
@@ -1429,6 +1487,7 @@ public:
     x.arrays=ah.release();
     x.size_ctrl.ml=x.initial_max_load();
     x.size_ctrl.size=0;
+    BOOST_UNORDERED_SWAP_STATS(cstats,x.cstats);
   }
 
   table_core(table_core&& x)
@@ -1454,11 +1513,13 @@ public:
       using std::swap;
       swap(arrays,x.arrays);
       swap(size_ctrl,x.size_ctrl);
+      BOOST_UNORDERED_SWAP_STATS(cstats,x.cstats);
     }
     else{
       reserve(x.size());
       clear_on_exit c{x};
       (void)c; /* unused var warning */
+      BOOST_UNORDERED_RESET_STATS_OF(x);
 
       /* This works because subsequent x.clear() does not depend on the
        * elements' values.
@@ -1574,9 +1635,11 @@ public:
         arrays=x.arrays;
         size_ctrl.ml=std::size_t(x.size_ctrl.ml);
         size_ctrl.size=std::size_t(x.size_ctrl.size);
+        BOOST_UNORDERED_COPY_STATS(cstats,x.cstats);
         x.arrays=ah.release();
         x.size_ctrl.ml=x.initial_max_load();
         x.size_ctrl.size=0;
+        BOOST_UNORDERED_RESET_STATS_OF(x);
       }
       else{
         swap(h(),x.h());
@@ -1586,6 +1649,7 @@ public:
         noshrink_reserve(x.size());
         clear_on_exit c{x};
         (void)c; /* unused var warning */
+        BOOST_UNORDERED_RESET_STATS_OF(x);
 
         /* This works because subsequent x.clear() does not depend on the
          * elements' values.
@@ -1639,6 +1703,7 @@ public:
   BOOST_FORCEINLINE locator find(
     const Key& x,std::size_t pos0,std::size_t hash)const
   {    
+    BOOST_UNORDERED_STATS_COUNTER(num_cmps);
     prober pb(pos0);
     do{
       auto pos=pb.get();
@@ -1650,18 +1715,25 @@ public:
         auto p=elements+pos*N;
         BOOST_UNORDERED_PREFETCH_ELEMENTS(p,N);
         do{
+          BOOST_UNORDERED_INCREMENT_STATS_COUNTER(num_cmps);
           auto n=unchecked_countr_zero(mask);
           if(BOOST_LIKELY(bool(pred()(x,key_from(p[n]))))){
+            BOOST_UNORDERED_ADD_STATS(
+              cstats.successful_lookup,(pb.length(),num_cmps));
             return {pg,n,p+n};
           }
           mask&=mask-1;
         }while(mask);
       }
       if(BOOST_LIKELY(pg->is_not_overflowed(hash))){
+        BOOST_UNORDERED_ADD_STATS(
+          cstats.unsuccessful_lookup,(pb.length(),num_cmps));
         return {};
       }
     }
     while(BOOST_LIKELY(pb.next(arrays.groups_size_mask)));
+    BOOST_UNORDERED_ADD_STATS(
+      cstats.unsuccessful_lookup,(pb.length(),num_cmps));
     return {};
   }
 
@@ -1746,6 +1818,38 @@ public:
     rehash(std::size_t(std::ceil(float(n)/mlf)));
   }
 
+#if defined(BOOST_UNORDERED_ENABLE_STATS)
+  stats get_stats()const
+  {
+    auto insertion=cstats.insertion.get_summary();
+    auto successful_lookup=cstats.successful_lookup.get_summary();
+    auto unsuccessful_lookup=cstats.unsuccessful_lookup.get_summary();
+    return{
+      {
+        insertion.count,
+        insertion.sequence_summary[0]
+      },
+      {
+        successful_lookup.count,
+        successful_lookup.sequence_summary[0],
+        successful_lookup.sequence_summary[1]
+      },
+      {
+        unsuccessful_lookup.count,
+        unsuccessful_lookup.sequence_summary[0],
+        unsuccessful_lookup.sequence_summary[1]
+      },
+    };
+  }
+
+  void reset_stats()noexcept
+  {
+    cstats.insertion.reset();
+    cstats.successful_lookup.reset();
+    cstats.unsuccessful_lookup.reset();
+  }
+#endif
+
   friend bool operator==(const table_core& x,const table_core& y)
   {
     return
@@ -1953,8 +2057,12 @@ public:
     return true;
   }
 
-  arrays_type    arrays;
-  size_ctrl_type size_ctrl;
+  arrays_type              arrays;
+  size_ctrl_type           size_ctrl;
+
+#if defined(BOOST_UNORDERED_ENABLE_STATS)
+  mutable cumulative_stats cstats;
+#endif
 
 private:
   template<
@@ -2243,6 +2351,7 @@ private:
         auto p=arrays_.elements()+pos*N+n;
         construct_element(p,std::forward<Args>(args)...);
         pg->set(n,hash);
+        BOOST_UNORDERED_ADD_STATS(cstats.insertion,(pb.length()));
         return {pg,n,p};
       }
       else pg->mark_overflow(hash);

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

@@ -0,0 +1,177 @@
+/* Copyright 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)
+ *
+ * See https://www.boost.org/libs/unordered for library home page.
+ */
+
+#ifndef BOOST_UNORDERED_DETAIL_FOA_CUMULATIVE_STATS_HPP
+#define BOOST_UNORDERED_DETAIL_FOA_CUMULATIVE_STATS_HPP
+
+#include <array>
+#include <boost/config.hpp>
+#include <boost/mp11/tuple.hpp>
+#include <cmath>
+#include <cstddef>
+
+#if defined(BOOST_HAS_THREADS)
+#include <boost/unordered/detail/foa/rw_spinlock.hpp>
+#include <mutex>
+#endif
+
+namespace boost{
+namespace unordered{
+namespace detail{
+namespace foa{
+
+/* Cumulative one-pass calculation of the average, variance and deviation of
+ * running sequences.
+ */
+
+struct sequence_stats_data
+{
+  double m=0.0;
+  double m_prior=0.0;
+  double s=0.0;
+};
+
+struct welfords_algorithm /* 0-based */
+{
+  template<typename T>
+  int operator()(T&& x,sequence_stats_data& d)const noexcept
+  {
+    static_assert(
+      noexcept(static_cast<double>(x)),
+      "Argument conversion to double must not throw.");
+
+    d.m_prior=d.m;
+    d.m+=(static_cast<double>(x)-d.m)/static_cast<double>(n);
+    d.s+=(n!=1)*
+      (static_cast<double>(x)-d.m_prior)*(static_cast<double>(x)-d.m);
+
+    return 0; /* mp11::tuple_transform requires that return type not be void */
+  }
+
+  std::size_t n;
+};
+
+struct sequence_stats_summary
+{
+  double average;
+  double variance;
+  double deviation;
+};
+
+/* Stats calculated jointly for N same-sized sequences to save the space
+ * for count.
+ */
+
+template<std::size_t N>
+class cumulative_stats
+{
+public:
+  struct summary
+  {
+    std::size_t                          count;
+    std::array<sequence_stats_summary,N> sequence_summary;
+  };
+
+  void reset()noexcept{*this=cumulative_stats();}
+  
+  template<typename... Ts>
+  void add(Ts&&... xs)noexcept
+  {
+    static_assert(
+      sizeof...(Ts)==N,"A sample must be provided for each sequence.");
+
+    if(BOOST_UNLIKELY(++n==0)){ /* wraparound */
+      reset();
+      n=1;
+    }
+    mp11::tuple_transform(
+      welfords_algorithm{n},
+      std::forward_as_tuple(std::forward<Ts>(xs)...),
+      data);
+  }
+  
+  summary get_summary()const noexcept
+  {
+    summary res;
+    res.count=n;
+    for(std::size_t i=0;i<N;++i){
+      double average=data[i].m,
+             variance=n!=0?data[i].s/static_cast<double>(n):0.0, /* biased */
+             deviation=std::sqrt(variance);
+      res.sequence_summary[i]={average,variance,deviation};
+    }
+    return res;
+  }
+
+private:
+  std::size_t                       n=0;
+  std::array<sequence_stats_data,N> data;
+};
+
+#if defined(BOOST_HAS_THREADS)
+
+template<std::size_t N>
+class concurrent_cumulative_stats:cumulative_stats<N>
+{
+  using super=cumulative_stats<N>;
+  using lock_guard=std::lock_guard<rw_spinlock>;
+
+public:
+  using summary=typename super::summary;
+
+  concurrent_cumulative_stats()noexcept:super{}{}
+  concurrent_cumulative_stats(const concurrent_cumulative_stats& x)noexcept:
+    concurrent_cumulative_stats{x,lock_guard{x.mut}}{}
+
+  concurrent_cumulative_stats&
+  operator=(const concurrent_cumulative_stats& x)noexcept
+  {
+    auto x1=x;
+    lock_guard lck{mut};
+    static_cast<super&>(*this)=x1;
+    return *this;
+  }
+
+  void reset()noexcept
+  {
+    lock_guard lck{mut};
+    super::reset();
+  }
+  
+  template<typename... Ts>
+  void add(Ts&&... xs)noexcept
+  {
+    lock_guard lck{mut};
+    super::add(std::forward<Ts>(xs)...);
+  }
+  
+  summary get_summary()const noexcept
+  {
+    lock_guard lck{mut};
+    return super::get_summary();
+  }
+
+private:
+  concurrent_cumulative_stats(const super& x,lock_guard&&):super{x}{}
+
+  mutable rw_spinlock mut;
+};
+
+#else
+
+template<std::size_t N>
+using concurrent_cumulative_stats=cumulative_stats<N>;
+
+#endif
+
+} /* namespace foa */
+} /* namespace detail */
+} /* namespace unordered */
+} /* namespace boost */
+
+#endif

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

@@ -1,6 +1,6 @@
 /* Fast open-addressing hash table.
  *
- * Copyright 2022-2023 Joaquin M Lopez Munoz.
+ * Copyright 2022-2024 Joaquin M Lopez Munoz.
  * Copyright 2023 Christian Mazakas.
  * Copyright 2024 Braden Ganetsky.
  * Distributed under the Boost Software License, Version 1.0.
@@ -361,6 +361,10 @@ public:
     const_iterator>::type;
   using erase_return_type=table_erase_return_type<iterator>;
 
+#if defined(BOOST_UNORDERED_ENABLE_STATS)
+  using stats=typename super::stats;
+#endif
+
   table(
     std::size_t n=default_bucket_count,const Hash& h_=Hash(),
     const Pred& pred_=Pred(),const Allocator& al_=Allocator()):
@@ -542,6 +546,11 @@ public:
   using super::rehash;
   using super::reserve;
 
+#if defined(BOOST_UNORDERED_ENABLE_STATS)
+  using super::get_stats;
+  using super::reset_stats;
+#endif
+
   template<typename Predicate>
   friend std::size_t erase_if(table& x,Predicate& pr)
   {
@@ -584,6 +593,7 @@ private:
     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);
   }
 
   template<typename ExclusiveLockGuard>

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

@@ -1,6 +1,6 @@
 /* Hash function characterization.
  *
- * Copyright 2022 Joaquin M Lopez Munoz.
+ * Copyright 2022-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)
@@ -19,12 +19,34 @@ namespace unordered{
 namespace detail{
 
 template<typename Hash,typename=void>
-struct hash_is_avalanching_impl: std::false_type{};
+struct hash_is_avalanching_impl:std::false_type{};
+
+template<typename IsAvalanching>
+struct avalanching_value
+{
+  static constexpr bool value=IsAvalanching::value;
+};
+
+/* may be explicitly marked as BOOST_DEPRECATED in the future */
+template<> struct avalanching_value<void>
+{
+  static constexpr bool value=true;
+};
+
+template<typename Hash>
+struct hash_is_avalanching_impl<
+  Hash,
+  boost::unordered::detail::void_t<typename Hash::is_avalanching>
+>:std::integral_constant<
+  bool,
+  avalanching_value<typename Hash::is_avalanching>::value
+>{};
 
 template<typename Hash>
-struct hash_is_avalanching_impl<Hash,
-  boost::unordered::detail::void_t<typename Hash::is_avalanching> >:
-    std::true_type{};
+struct hash_is_avalanching_impl<
+  Hash,
+  typename std::enable_if<((void)Hash::is_avalanching,true)>::type
+>{}; /* Hash::is_avalanching is not a type: compile error downstream */
 
 } /* namespace detail */
 
@@ -32,8 +54,12 @@ struct hash_is_avalanching_impl<Hash,
  * when actual characterization differs from default.
  */
 
-/* hash_is_avalanching<Hash>::value is true when the type Hash::is_avalanching
- * is present, false otherwise.
+/* hash_is_avalanching<Hash>::value is:
+ *   - false if Hash::is_avalanching is not present.
+ *   - Hash::is_avalanching::value if this is present and constexpr-convertible
+ *     to a bool.
+ *   - true if Hash::is_avalanching is void (deprecated).
+ *   - ill-formed otherwise.
  */
 template<typename Hash>
 struct hash_is_avalanching: detail::hash_is_avalanching_impl<Hash>::type{};

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

@@ -76,6 +76,10 @@ namespace boost {
       using iterator = typename table_type::iterator;
       using const_iterator = typename table_type::const_iterator;
 
+#if defined(BOOST_UNORDERED_ENABLE_STATS)
+      using stats = typename table_type::stats;
+#endif
+
       unordered_flat_map() : unordered_flat_map(0) {}
 
       explicit unordered_flat_map(size_type n, hasher const& h = hasher(),
@@ -654,6 +658,14 @@ namespace boost {
 
       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
       ///
 

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

@@ -1,5 +1,6 @@
 
 // Copyright (C) 2022 Christian Mazakas
+// Copyright (C) 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)
 
@@ -15,6 +16,10 @@
 #include <functional>
 #include <memory>
 
+#ifndef BOOST_NO_CXX17_HDR_MEMORY_RESOURCE
+#include <memory_resource>
+#endif
+
 namespace boost {
   namespace unordered {
     template <class Key, class T, class Hash = boost::hash<Key>,
@@ -36,6 +41,16 @@ namespace boost {
     void swap(unordered_flat_map<Key, T, Hash, KeyEqual, Allocator>& lhs,
       unordered_flat_map<Key, T, Hash, KeyEqual, Allocator>& rhs)
       noexcept(noexcept(lhs.swap(rhs)));
+
+#ifndef BOOST_NO_CXX17_HDR_MEMORY_RESOURCE
+    namespace pmr {
+      template <class Key, class T, class Hash = boost::hash<Key>,
+        class KeyEqual = std::equal_to<Key> >
+      using unordered_flat_map =
+        boost::unordered::unordered_flat_map<Key, T, Hash, KeyEqual,
+          std::pmr::polymorphic_allocator<std::pair<const Key, T> > >;
+    } // namespace pmr
+#endif
   } // namespace unordered
 
   using boost::unordered::unordered_flat_map;

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

@@ -72,6 +72,10 @@ namespace boost {
       using iterator = typename table_type::iterator;
       using const_iterator = typename table_type::const_iterator;
 
+#if defined(BOOST_UNORDERED_ENABLE_STATS)
+      using stats = typename table_type::stats;
+#endif
+
       unordered_flat_set() : unordered_flat_set(0) {}
 
       explicit unordered_flat_set(size_type n, hasher const& h = hasher(),
@@ -474,6 +478,14 @@ namespace boost {
 
       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
       ///
 

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

@@ -1,5 +1,6 @@
 
 // Copyright (C) 2022 Christian Mazakas
+// Copyright (C) 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)
 
@@ -15,6 +16,10 @@
 #include <functional>
 #include <memory>
 
+#ifndef BOOST_NO_CXX17_HDR_MEMORY_RESOURCE
+#include <memory_resource>
+#endif
+
 namespace boost {
   namespace unordered {
     template <class Key, class Hash = boost::hash<Key>,
@@ -36,6 +41,15 @@ namespace boost {
     void swap(unordered_flat_set<Key, Hash, KeyEqual, Allocator>& lhs,
       unordered_flat_set<Key, Hash, KeyEqual, Allocator>& rhs)
       noexcept(noexcept(lhs.swap(rhs)));
+
+#ifndef BOOST_NO_CXX17_HDR_MEMORY_RESOURCE
+    namespace pmr {
+      template <class Key, class Hash = boost::hash<Key>,
+        class KeyEqual = std::equal_to<Key> >
+      using unordered_flat_set = boost::unordered::unordered_flat_set<Key, Hash,
+        KeyEqual, std::pmr::polymorphic_allocator<Key> >;
+    } // namespace pmr
+#endif
   } // namespace unordered
 
   using boost::unordered::unordered_flat_set;

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

@@ -1,6 +1,7 @@
 
 // Copyright (C) 2008-2011 Daniel James.
 // Copyright (C) 2022-2023 Christian Mazakas
+// Copyright (C) 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)
 
@@ -16,6 +17,10 @@
 #include <functional>
 #include <memory>
 
+#ifndef BOOST_NO_CXX17_HDR_MEMORY_RESOURCE
+#include <memory_resource>
+#endif
+
 namespace boost {
   namespace unordered {
     template <class K, class T, class H = boost::hash<K>,
@@ -58,6 +63,20 @@ namespace boost {
 
     template <class N, class K, class T, class A> class node_handle_map;
     template <class Iter, class NodeType> struct insert_return_type_map;
+
+#ifndef BOOST_NO_CXX17_HDR_MEMORY_RESOURCE
+    namespace pmr {
+      template <class K, class T, class H = boost::hash<K>,
+        class P = std::equal_to<K> >
+      using unordered_map = boost::unordered::unordered_map<K, T, H, P,
+        std::pmr::polymorphic_allocator<std::pair<const K, T> > >;
+
+      template <class K, class T, class H = boost::hash<K>,
+        class P = std::equal_to<K> >
+      using unordered_multimap = boost::unordered::unordered_multimap<K, T, H,
+        P, std::pmr::polymorphic_allocator<std::pair<const K, T> > >;
+    } // namespace pmr
+#endif
   } // namespace unordered
 
   using boost::unordered::unordered_map;

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

@@ -115,6 +115,10 @@ namespace boost {
       using insert_return_type =
         detail::foa::insert_return_type<iterator, node_type>;
 
+#if defined(BOOST_UNORDERED_ENABLE_STATS)
+      using stats = typename table_type::stats;
+#endif
+
       unordered_node_map() : unordered_node_map(0) {}
 
       explicit unordered_node_map(size_type n, hasher const& h = hasher(),
@@ -749,6 +753,14 @@ namespace boost {
 
       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
       ///