fourth attempt

micro-optimized previous
third attempt
2026-08-09 23:21:17 +02:00 · 2022-11-28 17:58:15 +01:00 · 2022-11-28 12:13:04 +01:00 · 2022-11-27 20:54:26 +01:00 · 2022-11-24 20:12:48 +01:00 · 2022-11-24 20:00:04 +01:00
33 changed files with 554 additions and 1929 deletions
@@ -217,13 +217,11 @@ jobs:
      fail-fast: false
      matrix:
        include:
-          - { toolset: msvc-14.0, cxxstd: '14,latest',       addrmd: '32,64', os: windows-2019, variant: 'debug,release' }
-          - { toolset: msvc-14.2, cxxstd: '14,17,20,latest', addrmd: '32,64', os: windows-2019, variant: 'debug,release' }
-          - { toolset: msvc-14.3, cxxstd: '14,17,20,latest', addrmd: '32,64', os: windows-2022, variant: 'debug,release' }
-          - { toolset: msvc-14.3, cxxstd: '14',              addrmd: '64',    os: windows-2022, variant: 'debug', defines: '_ALLOW_RTCc_IN_STL', cxxflags: '/RTCc'              }
-          - { toolset: msvc-14.3, cxxstd: '14',              addrmd: '32',    os: windows-2022, variant: 'debug', defines: '_ALLOW_RTCc_IN_STL', cxxflags: '"/RTCc /arch:IA32"' }
-          - { toolset: clang-win, cxxstd: '14,17,latest',    addrmd: '32,64', os: windows-2022, variant: 'debug,release' }
-          - { toolset: gcc,       cxxstd: '03,11,14,17,2a',  addrmd: '64',    os: windows-2019, variant: 'debug,release' }
+          - { toolset: msvc-14.0, cxxstd: '14,latest',       addrmd: '32,64', os: windows-2019 }
+          - { toolset: msvc-14.2, cxxstd: '14,17,20,latest', addrmd: '32,64', os: windows-2019 }
+          - { toolset: msvc-14.3, cxxstd: '14,17,20,latest', addrmd: '32,64', os: windows-2022 }
+          - { toolset: clang-win, cxxstd: '14,17,latest',    addrmd: '32,64', os: windows-2022 }
+          - { toolset: gcc,       cxxstd: '03,11,14,17,2a',  addrmd: '64',    os: windows-2019 }

    runs-on: ${{matrix.os}}

@@ -252,9 +250,6 @@ jobs:
          B2_TOOLSET: ${{matrix.toolset}}
          B2_CXXSTD: ${{matrix.cxxstd}}
          B2_ADDRESS_MODEL: ${{matrix.addrmd}}
-          B2_DEFINES: ${{matrix.defines}}
-          B2_VARIANT: ${{matrix.variant}}
-          B2_CXXFLAGS: ${{matrix.cxxflags}}

      - name: Collect coverage
        shell: powershell
@@ -1,3 +0,0 @@
-enwik8
-enwik9
-*.exe
@@ -3,18 +3,23 @@
 // https://www.boost.org/LICENSE_1_0.txt

 #define _SILENCE_CXX17_OLD_ALLOCATOR_MEMBERS_DEPRECATION_WARNING
-#define _SILENCE_CXX20_CISO646_REMOVED_WARNING

 #include <boost/unordered_map.hpp>
 #include <boost/unordered/unordered_flat_map.hpp>
+#include <boost/multi_index_container.hpp>
+#include <boost/multi_index/hashed_index.hpp>
+#include <boost/multi_index/member.hpp>
 #include <boost/core/detail/splitmix64.hpp>
 #include <boost/config.hpp>
 #ifdef HAVE_ABSEIL
 # include "absl/container/node_hash_map.h"
 # include "absl/container/flat_hash_map.h"
 #endif
-#ifdef HAVE_ANKERL_UNORDERED_DENSE
-# include "ankerl/unordered_dense.h"
+#ifdef HAVE_TSL_HOPSCOTCH
+# include "tsl/hopscotch_map.h"
+#endif
+#ifdef HAVE_TSL_ROBIN
+# include "tsl/robin_map.h"
 #endif
 #include <unordered_map>
 #include <vector>
@@ -262,6 +267,24 @@ template<template<class...> class Map> BOOST_NOINLINE void test( char const* lab
    times.push_back( rec );
 }

+// multi_index emulation of unordered_map
+
+template<class K, class V> struct pair
+{
+    K first;
+    mutable V second;
+};
+
+using namespace boost::multi_index;
+
+template<class K, class V> using multi_index_map = multi_index_container<
+  pair<K, V>,
+  indexed_by<
+    hashed_unique< member<pair<K, V>, K, &pair<K, V>::first> >
+  >,
+  ::allocator< pair<K, V> >
+>;
+
 // aliases using the counting allocator

 template<class K, class V> using allocator_for = ::allocator< std::pair<K const, V> >;
@@ -285,10 +308,23 @@ template<class K, class V> using absl_flat_hash_map =

 #endif

-#ifdef HAVE_ANKERL_UNORDERED_DENSE
+#ifdef HAVE_TSL_HOPSCOTCH

-template<class K, class V> using ankerl_unordered_dense_map =
-    ankerl::unordered_dense::map<K, V, ankerl::unordered_dense::hash<K>, std::equal_to<K>, ::allocator< std::pair<K, V> >>;
+template<class K, class V> using tsl_hopscotch_map =
+    tsl::hopscotch_map<K, V, std::hash<K>, std::equal_to<K>, ::allocator< std::pair<K, V> >>;
+
+template<class K, class V> using tsl_hopscotch_pg_map =
+    tsl::hopscotch_pg_map<K, V, std::hash<K>, std::equal_to<K>, ::allocator< std::pair<K, V> >>;
+
+#endif
+
+#ifdef HAVE_TSL_ROBIN
+
+template<class K, class V> using tsl_robin_map =
+    tsl::robin_map<K, V, std::hash<K>, std::equal_to<K>, ::allocator< std::pair<K, V> >>;
+
+template<class K, class V> using tsl_robin_pg_map =
+    tsl::robin_pg_map<K, V, std::hash<K>, std::equal_to<K>, ::allocator< std::pair<K, V> >>;

 #endif

@@ -348,6 +384,14 @@ template<class K, class V> using boost_unordered_map_fnv1a =
 template<class K, class V> using boost_unordered_flat_map_fnv1a =
    boost::unordered_flat_map<K, V, fnv1a_hash, std::equal_to<K>, allocator_for<K, V>>;

+template<class K, class V> using multi_index_map_fnv1a = multi_index_container<
+  pair<K, V>,
+  indexed_by<
+    hashed_unique< member<pair<K, V>, K, &pair<K, V>::first>, fnv1a_hash >
+  >,
+  ::allocator< pair<K, V> >
+>;
+
 #ifdef HAVE_ABSEIL

 template<class K, class V> using absl_node_hash_map_fnv1a =
@@ -358,10 +402,23 @@ template<class K, class V> using absl_flat_hash_map_fnv1a =

 #endif

-#ifdef HAVE_ANKERL_UNORDERED_DENSE
+#ifdef HAVE_TSL_HOPSCOTCH

-template<class K, class V> using ankerl_unordered_dense_map_fnv1a =
-    ankerl::unordered_dense::map<K, V, fnv1a_hash, std::equal_to<K>, ::allocator< std::pair<K, V> >>;
+template<class K, class V> using tsl_hopscotch_map_fnv1a =
+    tsl::hopscotch_map<K, V, fnv1a_hash, std::equal_to<K>, ::allocator< std::pair<K, V> >>;
+
+template<class K, class V> using tsl_hopscotch_pg_map_fnv1a =
+    tsl::hopscotch_pg_map<K, V, fnv1a_hash, std::equal_to<K>, ::allocator< std::pair<K, V> >>;
+
+#endif
+
+#ifdef HAVE_TSL_ROBIN
+
+template<class K, class V> using tsl_robin_map_fnv1a =
+    tsl::robin_map<K, V, fnv1a_hash, std::equal_to<K>, ::allocator< std::pair<K, V> >>;
+
+template<class K, class V> using tsl_robin_pg_map_fnv1a =
+    tsl::robin_pg_map<K, V, fnv1a_hash, std::equal_to<K>, ::allocator< std::pair<K, V> >>;

 #endif

@@ -371,45 +428,67 @@ int main()
 {
    init_indices();

+#if 1
+
    test<std_unordered_map>( "std::unordered_map" );
    test<boost_unordered_map>( "boost::unordered_map" );
    test<boost_unordered_flat_map>( "boost::unordered_flat_map" );
-
-#ifdef HAVE_ANKERL_UNORDERED_DENSE
-
-    test<ankerl_unordered_dense_map>( "ankerl::unordered_dense::map" );
-
-#endif
+    test<multi_index_map>( "multi_index_map" );

 #ifdef HAVE_ABSEIL

    test<absl_node_hash_map>( "absl::node_hash_map" );
    test<absl_flat_hash_map>( "absl::flat_hash_map" );

+#endif
+
+#ifdef HAVE_TSL_HOPSCOTCH
+
+    test<tsl_hopscotch_map>( "tsl::hopscotch_map" );
+    test<tsl_hopscotch_pg_map>( "tsl::hopscotch_pg_map" );
+
+#endif
+
+#ifdef HAVE_TSL_ROBIN
+
+    test<tsl_robin_map>( "tsl::robin_map" );
+    test<tsl_robin_pg_map>( "tsl::robin_pg_map" );
+
+#endif
+
 #endif

    test<std_unordered_map_fnv1a>( "std::unordered_map, FNV-1a" );
    test<boost_unordered_map_fnv1a>( "boost::unordered_map, FNV-1a" );
    test<boost_unordered_flat_map_fnv1a>( "boost::unordered_flat_map, FNV-1a" );
-
-#ifdef HAVE_ANKERL_UNORDERED_DENSE
-
-    test<ankerl_unordered_dense_map_fnv1a>( "ankerl::unordered_dense::map, FNV-1a" );
-
-#endif
+    test<multi_index_map_fnv1a>( "multi_index_map, FNV-1a" );

 #ifdef HAVE_ABSEIL

    test<absl_node_hash_map_fnv1a>( "absl::node_hash_map, FNV-1a" );
    test<absl_flat_hash_map_fnv1a>( "absl::flat_hash_map, FNV-1a" );

+#endif
+
+#ifdef HAVE_TSL_HOPSCOTCH
+
+    test<tsl_hopscotch_map_fnv1a>( "tsl::hopscotch_map, FNV-1a" );
+    test<tsl_hopscotch_pg_map_fnv1a>( "tsl::hopscotch_pg_map, FNV-1a" );
+
+#endif
+
+#ifdef HAVE_TSL_ROBIN
+
+    test<tsl_robin_map_fnv1a>( "tsl::robin_map, FNV-1a" );
+    test<tsl_robin_pg_map_fnv1a>( "tsl::robin_pg_map, FNV-1a" );
+
 #endif

    std::cout << "---\n\n";

    for( auto const& x: times )
    {
-        std::cout << std::setw( 38 ) << ( x.label_ + ": " ) << std::setw( 5 ) << x.time_ << " ms, " << std::setw( 9 ) << x.bytes_ << " bytes in " << x.count_ << " allocations\n";
+        std::cout << std::setw( 35 ) << ( x.label_ + ": " ) << std::setw( 5 ) << x.time_ << " ms, " << std::setw( 9 ) << x.bytes_ << " bytes in " << x.count_ << " allocations\n";
    }
 }

@@ -3,18 +3,23 @@
 // https://www.boost.org/LICENSE_1_0.txt

 #define _SILENCE_CXX17_OLD_ALLOCATOR_MEMBERS_DEPRECATION_WARNING
-#define _SILENCE_CXX20_CISO646_REMOVED_WARNING

 #include <boost/unordered_map.hpp>
 #include <boost/unordered/unordered_flat_map.hpp>
+#include <boost/multi_index_container.hpp>
+#include <boost/multi_index/hashed_index.hpp>
+#include <boost/multi_index/member.hpp>
 #include <boost/core/detail/splitmix64.hpp>
 #include <boost/config.hpp>
 #ifdef HAVE_ABSEIL
 # include "absl/container/node_hash_map.h"
 # include "absl/container/flat_hash_map.h"
 #endif
-#ifdef HAVE_ANKERL_UNORDERED_DENSE
-# include "ankerl/unordered_dense.h"
+#ifdef HAVE_TSL_HOPSCOTCH
+# include "tsl/hopscotch_map.h"
+#endif
+#ifdef HAVE_TSL_ROBIN
+# include "tsl/robin_map.h"
 #endif
 #include <unordered_map>
 #include <string_view>
@@ -263,6 +268,24 @@ template<template<class...> class Map> BOOST_NOINLINE void test( char const* lab
    times.push_back( rec );
 }

+// multi_index emulation of unordered_map
+
+template<class K, class V> struct pair
+{
+    K first;
+    mutable V second;
+};
+
+using namespace boost::multi_index;
+
+template<class K, class V> using multi_index_map = multi_index_container<
+  pair<K, V>,
+  indexed_by<
+    hashed_unique< member<pair<K, V>, K, &pair<K, V>::first> >
+  >,
+  ::allocator< pair<K, V> >
+>;
+
 // aliases using the counting allocator

 template<class K, class V> using allocator_for = ::allocator< std::pair<K const, V> >;
@@ -286,10 +309,23 @@ template<class K, class V> using absl_flat_hash_map =

 #endif

-#ifdef HAVE_ANKERL_UNORDERED_DENSE
+#ifdef HAVE_TSL_HOPSCOTCH

-template<class K, class V> using ankerl_unordered_dense_map =
-    ankerl::unordered_dense::map<K, V, ankerl::unordered_dense::hash<K>, std::equal_to<K>, ::allocator< std::pair<K, V> >>;
+template<class K, class V> using tsl_hopscotch_map =
+    tsl::hopscotch_map<K, V, std::hash<K>, std::equal_to<K>, ::allocator< std::pair<K, V> >>;
+
+template<class K, class V> using tsl_hopscotch_pg_map =
+    tsl::hopscotch_pg_map<K, V, std::hash<K>, std::equal_to<K>, ::allocator< std::pair<K, V> >>;
+
+#endif
+
+#ifdef HAVE_TSL_ROBIN
+
+template<class K, class V> using tsl_robin_map =
+    tsl::robin_map<K, V, std::hash<K>, std::equal_to<K>, ::allocator< std::pair<K, V> >>;
+
+template<class K, class V> using tsl_robin_pg_map =
+    tsl::robin_pg_map<K, V, std::hash<K>, std::equal_to<K>, ::allocator< std::pair<K, V> >>;

 #endif

@@ -349,6 +385,14 @@ template<class K, class V> using boost_unordered_map_fnv1a =
 template<class K, class V> using boost_unordered_flat_map_fnv1a =
    boost::unordered_flat_map<K, V, fnv1a_hash, std::equal_to<K>, allocator_for<K, V>>;

+template<class K, class V> using multi_index_map_fnv1a = multi_index_container<
+  pair<K, V>,
+  indexed_by<
+    hashed_unique< member<pair<K, V>, K, &pair<K, V>::first>, fnv1a_hash >
+  >,
+  ::allocator< pair<K, V> >
+>;
+
 #ifdef HAVE_ABSEIL

 template<class K, class V> using absl_node_hash_map_fnv1a =
@@ -359,10 +403,23 @@ template<class K, class V> using absl_flat_hash_map_fnv1a =

 #endif

-#ifdef HAVE_ANKERL_UNORDERED_DENSE
+#ifdef HAVE_TSL_HOPSCOTCH

-template<class K, class V> using ankerl_unordered_dense_map_fnv1a =
-    ankerl::unordered_dense::map<K, V, fnv1a_hash, std::equal_to<K>, ::allocator< std::pair<K, V> >>;
+template<class K, class V> using tsl_hopscotch_map_fnv1a =
+    tsl::hopscotch_map<K, V, fnv1a_hash, std::equal_to<K>, ::allocator< std::pair<K, V> >>;
+
+template<class K, class V> using tsl_hopscotch_pg_map_fnv1a =
+    tsl::hopscotch_pg_map<K, V, fnv1a_hash, std::equal_to<K>, ::allocator< std::pair<K, V> >>;
+
+#endif
+
+#ifdef HAVE_TSL_ROBIN
+
+template<class K, class V> using tsl_robin_map_fnv1a =
+    tsl::robin_map<K, V, fnv1a_hash, std::equal_to<K>, ::allocator< std::pair<K, V> >>;
+
+template<class K, class V> using tsl_robin_pg_map_fnv1a =
+    tsl::robin_pg_map<K, V, fnv1a_hash, std::equal_to<K>, ::allocator< std::pair<K, V> >>;

 #endif

@@ -372,45 +429,67 @@ int main()
 {
    init_indices();

+#if 1
+
    test<std_unordered_map>( "std::unordered_map" );
    test<boost_unordered_map>( "boost::unordered_map" );
    test<boost_unordered_flat_map>( "boost::unordered_flat_map" );
-
-#ifdef HAVE_ANKERL_UNORDERED_DENSE
-
-    test<ankerl_unordered_dense_map>( "ankerl::unordered_dense::map" );
-
-#endif
+    test<multi_index_map>( "multi_index_map" );

 #ifdef HAVE_ABSEIL

    test<absl_node_hash_map>( "absl::node_hash_map" );
    test<absl_flat_hash_map>( "absl::flat_hash_map" );

+#endif
+
+#ifdef HAVE_TSL_HOPSCOTCH
+
+    test<tsl_hopscotch_map>( "tsl::hopscotch_map" );
+    test<tsl_hopscotch_pg_map>( "tsl::hopscotch_pg_map" );
+
+#endif
+
+#ifdef HAVE_TSL_ROBIN
+
+    test<tsl_robin_map>( "tsl::robin_map" );
+    test<tsl_robin_pg_map>( "tsl::robin_pg_map" );
+
+#endif
+
 #endif

    test<std_unordered_map_fnv1a>( "std::unordered_map, FNV-1a" );
    test<boost_unordered_map_fnv1a>( "boost::unordered_map, FNV-1a" );
    test<boost_unordered_flat_map_fnv1a>( "boost::unordered_flat_map, FNV-1a" );
-
-#ifdef HAVE_ANKERL_UNORDERED_DENSE
-
-    test<ankerl_unordered_dense_map_fnv1a>( "ankerl::unordered_dense::map, FNV-1a" );
-
-#endif
+    test<multi_index_map_fnv1a>( "multi_index_map, FNV-1a" );

 #ifdef HAVE_ABSEIL

    test<absl_node_hash_map_fnv1a>( "absl::node_hash_map, FNV-1a" );
    test<absl_flat_hash_map_fnv1a>( "absl::flat_hash_map, FNV-1a" );

+#endif
+
+#ifdef HAVE_TSL_HOPSCOTCH
+
+    test<tsl_hopscotch_map_fnv1a>( "tsl::hopscotch_map, FNV-1a" );
+    test<tsl_hopscotch_pg_map_fnv1a>( "tsl::hopscotch_pg_map, FNV-1a" );
+
+#endif
+
+#ifdef HAVE_TSL_ROBIN
+
+    test<tsl_robin_map_fnv1a>( "tsl::robin_map, FNV-1a" );
+    test<tsl_robin_pg_map_fnv1a>( "tsl::robin_pg_map, FNV-1a" );
+
 #endif

    std::cout << "---\n\n";

    for( auto const& x: times )
    {
-        std::cout << std::setw( 38 ) << ( x.label_ + ": " ) << std::setw( 5 ) << x.time_ << " ms, " << std::setw( 9 ) << x.bytes_ << " bytes in " << x.count_ << " allocations\n";
+        std::cout << std::setw( 35 ) << ( x.label_ + ": " ) << std::setw( 5 ) << x.time_ << " ms, " << std::setw( 9 ) << x.bytes_ << " bytes in " << x.count_ << " allocations\n";
    }
 }

@@ -3,10 +3,12 @@
 // https://www.boost.org/LICENSE_1_0.txt

 #define _SILENCE_CXX17_OLD_ALLOCATOR_MEMBERS_DEPRECATION_WARNING
-#define _SILENCE_CXX20_CISO646_REMOVED_WARNING

 #include <boost/unordered_map.hpp>
 #include <boost/unordered/unordered_flat_map.hpp>
+#include <boost/multi_index_container.hpp>
+#include <boost/multi_index/hashed_index.hpp>
+#include <boost/multi_index/member.hpp>
 #include <boost/endian/conversion.hpp>
 #include <boost/core/detail/splitmix64.hpp>
 #include <boost/config.hpp>
@@ -14,8 +16,11 @@
 # include "absl/container/node_hash_map.h"
 # include "absl/container/flat_hash_map.h"
 #endif
-#ifdef HAVE_ANKERL_UNORDERED_DENSE
-# include "ankerl/unordered_dense.h"
+#ifdef HAVE_TSL_HOPSCOTCH
+# include "tsl/hopscotch_map.h"
+#endif
+#ifdef HAVE_TSL_ROBIN
+# include "tsl/robin_map.h"
 #endif
 #include <unordered_map>
 #include <vector>
@@ -279,6 +284,24 @@ template<template<class...> class Map> BOOST_NOINLINE void test( char const* lab
    times.push_back( rec );
 }

+// multi_index emulation of unordered_map
+
+template<class K, class V> struct pair
+{
+    K first;
+    mutable V second;
+};
+
+using namespace boost::multi_index;
+
+template<class K, class V> using multi_index_map = multi_index_container<
+  pair<K, V>,
+  indexed_by<
+    hashed_unique< member<pair<K, V>, K, &pair<K, V>::first> >
+  >,
+  ::allocator< pair<K, V> >
+>;
+
 // aliases using the counting allocator

 template<class K, class V> using allocator_for = ::allocator< std::pair<K const, V> >;
@@ -289,20 +312,8 @@ template<class K, class V> using std_unordered_map =
 template<class K, class V> using boost_unordered_map =
    boost::unordered_map<K, V, boost::hash<K>, std::equal_to<K>, allocator_for<K, V>>;

-template<class K, class V> using boost_unordered_flat_map_xmx =
-    boost::unordered_flat_map<K, V, boost::hash<K>, std::equal_to<K>, allocator_for<K, V>, boost::unordered::detail::foa::xmx_mix>;
-
-template<class K, class V> using boost_unordered_flat_map_xmx2 =
-    boost::unordered_flat_map<K, V, boost::hash<K>, std::equal_to<K>, allocator_for<K, V>, boost::unordered::detail::foa::xmx2_mix>;
-
-template<class K, class V> using boost_unordered_flat_map_xmx3 =
-    boost::unordered_flat_map<K, V, boost::hash<K>, std::equal_to<K>, allocator_for<K, V>, boost::unordered::detail::foa::xmx3_mix>;
-
-template<class K, class V> using boost_unordered_flat_map_mulx =
-    boost::unordered_flat_map<K, V, boost::hash<K>, std::equal_to<K>, allocator_for<K, V>, boost::unordered::detail::foa::mulx_mix>;
-
-template<class K, class V> using boost_unordered_flat_map_mulx2 =
-    boost::unordered_flat_map<K, V, boost::hash<K>, std::equal_to<K>, allocator_for<K, V>, boost::unordered::detail::foa::mulx2_mix>;
+template<class K, class V> using boost_unordered_flat_map =
+    boost::unordered_flat_map<K, V, boost::hash<K>, std::equal_to<K>, allocator_for<K, V>>;

 #ifdef HAVE_ABSEIL

@@ -314,10 +325,23 @@ template<class K, class V> using absl_flat_hash_map =

 #endif

-#ifdef HAVE_ANKERL_UNORDERED_DENSE
+#ifdef HAVE_TSL_HOPSCOTCH

-template<class K, class V> using ankerl_unordered_dense_map =
-    ankerl::unordered_dense::map<K, V, ankerl::unordered_dense::hash<K>, std::equal_to<K>, ::allocator< std::pair<K, V> >>;
+template<class K, class V> using tsl_hopscotch_map =
+    tsl::hopscotch_map<K, V, std::hash<K>, std::equal_to<K>, ::allocator< std::pair<K, V> >>;
+
+template<class K, class V> using tsl_hopscotch_pg_map =
+    tsl::hopscotch_pg_map<K, V, std::hash<K>, std::equal_to<K>, ::allocator< std::pair<K, V> >>;
+
+#endif
+
+#ifdef HAVE_TSL_ROBIN
+
+template<class K, class V> using tsl_robin_map =
+    tsl::robin_map<K, V, std::hash<K>, std::equal_to<K>, ::allocator< std::pair<K, V> >>;
+
+template<class K, class V> using tsl_robin_pg_map =
+    tsl::robin_pg_map<K, V, std::hash<K>, std::equal_to<K>, ::allocator< std::pair<K, V> >>;

 #endif

@@ -327,31 +351,35 @@ int main()

    test<std_unordered_map>( "std::unordered_map" );
    test<boost_unordered_map>( "boost::unordered_map" );
-
-    test<boost_unordered_flat_map_xmx>( "boost::unordered_flat_map, xmx" );
-    test<boost_unordered_flat_map_xmx2>( "boost::unordered_flat_map, xmx2" );
-    test<boost_unordered_flat_map_xmx3>( "boost::unordered_flat_map, xmx3" );
-    test<boost_unordered_flat_map_mulx>( "boost::unordered_flat_map, mulx" );
-    test<boost_unordered_flat_map_mulx2>( "boost::unordered_flat_map, mulx2" );
-
-#ifdef HAVE_ANKERL_UNORDERED_DENSE
-
-    test<ankerl_unordered_dense_map>( "ankerl::unordered_dense::map" );
-
-#endif
+    test<boost_unordered_flat_map>( "boost::unordered_flat_map" );
+    test<multi_index_map>( "multi_index_map" );

 #ifdef HAVE_ABSEIL

    test<absl_node_hash_map>( "absl::node_hash_map" );
    test<absl_flat_hash_map>( "absl::flat_hash_map" );

+#endif
+
+#ifdef HAVE_TSL_HOPSCOTCH
+
+    test<tsl_hopscotch_map>( "tsl::hopscotch_map" );
+    test<tsl_hopscotch_pg_map>( "tsl::hopscotch_pg_map" );
+
+#endif
+
+#ifdef HAVE_TSL_ROBIN
+
+    test<tsl_robin_map>( "tsl::robin_map" );
+    test<tsl_robin_pg_map>( "tsl::robin_pg_map" );
+
 #endif

    std::cout << "---\n\n";

    for( auto const& x: times )
    {
-        std::cout << std::setw( 34 ) << ( x.label_ + ": " ) << std::setw( 5 ) << x.time_ << " ms, " << std::setw( 9 ) << x.bytes_ << " bytes in " << x.count_ << " allocations\n";
+        std::cout << std::setw( 27 ) << ( x.label_ + ": " ) << std::setw( 5 ) << x.time_ << " ms, " << std::setw( 9 ) << x.bytes_ << " bytes in " << x.count_ << " allocations\n";
    }
 }

@@ -3,10 +3,12 @@
 // https://www.boost.org/LICENSE_1_0.txt

 #define _SILENCE_CXX17_OLD_ALLOCATOR_MEMBERS_DEPRECATION_WARNING
-#define _SILENCE_CXX20_CISO646_REMOVED_WARNING

 #include <boost/unordered_map.hpp>
 #include <boost/unordered/unordered_flat_map.hpp>
+#include <boost/multi_index_container.hpp>
+#include <boost/multi_index/hashed_index.hpp>
+#include <boost/multi_index/member.hpp>
 #include <boost/endian/conversion.hpp>
 #include <boost/core/detail/splitmix64.hpp>
 #include <boost/config.hpp>
@@ -14,8 +16,11 @@
 # include "absl/container/node_hash_map.h"
 # include "absl/container/flat_hash_map.h"
 #endif
-#ifdef HAVE_ANKERL_UNORDERED_DENSE
-# include "ankerl/unordered_dense.h"
+#ifdef HAVE_TSL_HOPSCOTCH
+# include "tsl/hopscotch_map.h"
+#endif
+#ifdef HAVE_TSL_ROBIN
+# include "tsl/robin_map.h"
 #endif
 #include <unordered_map>
 #include <vector>
@@ -279,6 +284,24 @@ template<template<class...> class Map> BOOST_NOINLINE void test( char const* lab
    times.push_back( rec );
 }

+// multi_index emulation of unordered_map
+
+template<class K, class V> struct pair
+{
+    K first;
+    mutable V second;
+};
+
+using namespace boost::multi_index;
+
+template<class K, class V> using multi_index_map = multi_index_container<
+  pair<K, V>,
+  indexed_by<
+    hashed_unique< member<pair<K, V>, K, &pair<K, V>::first> >
+  >,
+  ::allocator< pair<K, V> >
+>;
+
 // aliases using the counting allocator

 template<class K, class V> using allocator_for = ::allocator< std::pair<K const, V> >;
@@ -289,20 +312,8 @@ template<class K, class V> using std_unordered_map =
 template<class K, class V> using boost_unordered_map =
    boost::unordered_map<K, V, boost::hash<K>, std::equal_to<K>, allocator_for<K, V>>;

-template<class K, class V> using boost_unordered_flat_map_xmx =
-    boost::unordered_flat_map<K, V, boost::hash<K>, std::equal_to<K>, allocator_for<K, V>, boost::unordered::detail::foa::xmx_mix>;
-
-template<class K, class V> using boost_unordered_flat_map_xmx2 =
-    boost::unordered_flat_map<K, V, boost::hash<K>, std::equal_to<K>, allocator_for<K, V>, boost::unordered::detail::foa::xmx2_mix>;
-
-template<class K, class V> using boost_unordered_flat_map_xmx3 =
-    boost::unordered_flat_map<K, V, boost::hash<K>, std::equal_to<K>, allocator_for<K, V>, boost::unordered::detail::foa::xmx3_mix>;
-
-template<class K, class V> using boost_unordered_flat_map_mulx =
-    boost::unordered_flat_map<K, V, boost::hash<K>, std::equal_to<K>, allocator_for<K, V>, boost::unordered::detail::foa::mulx_mix>;
-
-template<class K, class V> using boost_unordered_flat_map_mulx2 =
-    boost::unordered_flat_map<K, V, boost::hash<K>, std::equal_to<K>, allocator_for<K, V>, boost::unordered::detail::foa::mulx2_mix>;
+template<class K, class V> using boost_unordered_flat_map =
+    boost::unordered_flat_map<K, V, boost::hash<K>, std::equal_to<K>, allocator_for<K, V>>;

 #ifdef HAVE_ABSEIL

@@ -314,10 +325,23 @@ template<class K, class V> using absl_flat_hash_map =

 #endif

-#ifdef HAVE_ANKERL_UNORDERED_DENSE
+#ifdef HAVE_TSL_HOPSCOTCH

-template<class K, class V> using ankerl_unordered_dense_map =
-    ankerl::unordered_dense::map<K, V, ankerl::unordered_dense::hash<K>, std::equal_to<K>, ::allocator< std::pair<K, V> >>;
+template<class K, class V> using tsl_hopscotch_map =
+    tsl::hopscotch_map<K, V, std::hash<K>, std::equal_to<K>, ::allocator< std::pair<K, V> >>;
+
+template<class K, class V> using tsl_hopscotch_pg_map =
+    tsl::hopscotch_pg_map<K, V, std::hash<K>, std::equal_to<K>, ::allocator< std::pair<K, V> >>;
+
+#endif
+
+#ifdef HAVE_TSL_ROBIN
+
+template<class K, class V> using tsl_robin_map =
+    tsl::robin_map<K, V, std::hash<K>, std::equal_to<K>, ::allocator< std::pair<K, V> >>;
+
+template<class K, class V> using tsl_robin_pg_map =
+    tsl::robin_pg_map<K, V, std::hash<K>, std::equal_to<K>, ::allocator< std::pair<K, V> >>;

 #endif

@@ -325,43 +349,37 @@ int main()
 {
    init_indices();

-#if defined(BOOST_LIBSTDCXX_VERSION) && __SIZE_WIDTH__ == 32
-
-    // Pathological behavior:
-    // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=104945
-
-#else
-
    test<std_unordered_map>( "std::unordered_map" );
-
-#endif
-
    test<boost_unordered_map>( "boost::unordered_map" );
-
-    test<boost_unordered_flat_map_xmx>( "boost::unordered_flat_map, xmx" );
-    test<boost_unordered_flat_map_xmx2>( "boost::unordered_flat_map, xmx2" );
-    test<boost_unordered_flat_map_xmx3>( "boost::unordered_flat_map, xmx3" );
-    test<boost_unordered_flat_map_mulx>( "boost::unordered_flat_map, mulx" );
-    test<boost_unordered_flat_map_mulx2>( "boost::unordered_flat_map, mulx2" );
-
-#ifdef HAVE_ANKERL_UNORDERED_DENSE
-
-    test<ankerl_unordered_dense_map>( "ankerl::unordered_dense::map" );
-
-#endif
+    test<boost_unordered_flat_map>( "boost::unordered_flat_map" );
+    test<multi_index_map>( "multi_index_map" );

 #ifdef HAVE_ABSEIL

    test<absl_node_hash_map>( "absl::node_hash_map" );
    test<absl_flat_hash_map>( "absl::flat_hash_map" );

+#endif
+
+#ifdef HAVE_TSL_HOPSCOTCH
+
+    test<tsl_hopscotch_map>( "tsl::hopscotch_map" );
+    test<tsl_hopscotch_pg_map>( "tsl::hopscotch_pg_map" );
+
+#endif
+
+#ifdef HAVE_TSL_ROBIN
+
+    test<tsl_robin_map>( "tsl::robin_map" );
+    test<tsl_robin_pg_map>( "tsl::robin_pg_map" );
+
 #endif

    std::cout << "---\n\n";

    for( auto const& x: times )
    {
-        std::cout << std::setw( 34 ) << ( x.label_ + ": " ) << std::setw( 5 ) << x.time_ << " ms, " << std::setw( 9 ) << x.bytes_ << " bytes in " << x.count_ << " allocations\n";
+        std::cout << std::setw( 27 ) << ( x.label_ + ": " ) << std::setw( 5 ) << x.time_ << " ms, " << std::setw( 9 ) << x.bytes_ << " bytes in " << x.count_ << " allocations\n";
    }
 }

@@ -3,10 +3,12 @@
 // https://www.boost.org/LICENSE_1_0.txt

 #define _SILENCE_CXX17_OLD_ALLOCATOR_MEMBERS_DEPRECATION_WARNING
-#define _SILENCE_CXX20_CISO646_REMOVED_WARNING

 #include <boost/unordered_map.hpp>
 #include <boost/unordered/unordered_flat_map.hpp>
+#include <boost/multi_index_container.hpp>
+#include <boost/multi_index/hashed_index.hpp>
+#include <boost/multi_index/member.hpp>
 #include <boost/endian/conversion.hpp>
 #include <boost/core/detail/splitmix64.hpp>
 #include <boost/container_hash/hash.hpp>
@@ -15,9 +17,6 @@
 # include "absl/container/node_hash_map.h"
 # include "absl/container/flat_hash_map.h"
 #endif
-#ifdef HAVE_ANKERL_UNORDERED_DENSE
-# include "ankerl/unordered_dense.h"
-#endif
 #include <unordered_map>
 #include <vector>
 #include <memory>
@@ -330,6 +329,24 @@ template<template<class...> class Map> BOOST_NOINLINE void test( char const* lab
    times.push_back( rec );
 }

+// multi_index emulation of unordered_map
+
+template<class K, class V> struct pair
+{
+    K first;
+    mutable V second;
+};
+
+using namespace boost::multi_index;
+
+template<class K, class V> using multi_index_map = multi_index_container<
+  pair<K, V>,
+  indexed_by<
+    hashed_unique< member<pair<K, V>, K, &pair<K, V>::first> >
+  >,
+  ::allocator< pair<K, V> >
+>;
+
 // aliases using the counting allocator

 template<class K, class V> using allocator_for = ::allocator< std::pair<K const, V> >;
@@ -340,20 +357,8 @@ template<class K, class V> using std_unordered_map =
 template<class K, class V> using boost_unordered_map =
    boost::unordered_map<K, V, boost::hash<K>, std::equal_to<K>, allocator_for<K, V>>;

-template<class K, class V> using boost_unordered_flat_map_xmx =
-    boost::unordered_flat_map<K, V, boost::hash<K>, std::equal_to<K>, allocator_for<K, V>, boost::unordered::detail::foa::xmx_mix>;
-
-template<class K, class V> using boost_unordered_flat_map_xmx2 =
-    boost::unordered_flat_map<K, V, boost::hash<K>, std::equal_to<K>, allocator_for<K, V>, boost::unordered::detail::foa::xmx2_mix>;
-
-template<class K, class V> using boost_unordered_flat_map_xmx3 =
-    boost::unordered_flat_map<K, V, boost::hash<K>, std::equal_to<K>, allocator_for<K, V>, boost::unordered::detail::foa::xmx3_mix>;
-
-template<class K, class V> using boost_unordered_flat_map_mulx =
-    boost::unordered_flat_map<K, V, boost::hash<K>, std::equal_to<K>, allocator_for<K, V>, boost::unordered::detail::foa::mulx_mix>;
-
-template<class K, class V> using boost_unordered_flat_map_mulx2 =
-    boost::unordered_flat_map<K, V, boost::hash<K>, std::equal_to<K>, allocator_for<K, V>, boost::unordered::detail::foa::mulx2_mix>;
+template<class K, class V> using boost_unordered_flat_map =
+    boost::unordered_flat_map<K, V, boost::hash<K>, std::equal_to<K>, allocator_for<K, V>>;

 #ifdef HAVE_ABSEIL

@@ -365,31 +370,14 @@ template<class K, class V> using absl_flat_hash_map =

 #endif

-#ifdef HAVE_ANKERL_UNORDERED_DENSE
-
-template<class K, class V> using ankerl_unordered_dense_map =
-    ankerl::unordered_dense::map<K, V, ankerl::unordered_dense::hash<K>, std::equal_to<K>, ::allocator< std::pair<K, V> >>;
-
-#endif
-
 int main()
 {
    init_indices();

    test<std_unordered_map>( "std::unordered_map" );
    test<boost_unordered_map>( "boost::unordered_map" );
-
-    test<boost_unordered_flat_map_xmx>( "boost::unordered_flat_map, xmx" );
-    test<boost_unordered_flat_map_xmx2>( "boost::unordered_flat_map, xmx2" );
-    test<boost_unordered_flat_map_xmx3>( "boost::unordered_flat_map, xmx3" );
-    test<boost_unordered_flat_map_mulx>( "boost::unordered_flat_map, mulx" );
-    test<boost_unordered_flat_map_mulx2>( "boost::unordered_flat_map, mulx2" );
-
-#ifdef HAVE_ANKERL_UNORDERED_DENSE
-
-    test<ankerl_unordered_dense_map>( "ankerl::unordered_dense::map" );
-
-#endif
+    test<boost_unordered_flat_map>( "boost::unordered_flat_map" );
+    test<multi_index_map>( "multi_index_map" );

 #ifdef HAVE_ABSEIL

@@ -402,7 +390,7 @@ int main()

    for( auto const& x: times )
    {
-        std::cout << std::setw( 34 ) << ( x.label_ + ": " ) << std::setw( 5 ) << x.time_ << " ms, " << std::setw( 9 ) << x.bytes_ << " bytes in " << x.count_ << " allocations\n";
+        std::cout << std::setw( 27 ) << ( x.label_ + ": " ) << std::setw( 5 ) << x.time_ << " ms, " << std::setw( 9 ) << x.bytes_ << " bytes in " << x.count_ << " allocations\n";
    }
 }

@@ -1,376 +0,0 @@
-// Copyright 2021, 2022 Peter Dimov.
-// Distributed under the Boost Software License, Version 1.0.
-// https://www.boost.org/LICENSE_1_0.txt
-
-#define _SILENCE_CXX17_OLD_ALLOCATOR_MEMBERS_DEPRECATION_WARNING
-#define _SILENCE_CXX20_CISO646_REMOVED_WARNING
-
-#include <boost/unordered_map.hpp>
-#include <boost/unordered/unordered_flat_map.hpp>
-#include <boost/regex.hpp>
-#ifdef HAVE_ABSEIL
-# include "absl/container/node_hash_map.h"
-# include "absl/container/flat_hash_map.h"
-#endif
-#ifdef HAVE_ANKERL_UNORDERED_DENSE
-# include "ankerl/unordered_dense.h"
-#endif
-#include <unordered_map>
-#include <vector>
-#include <memory>
-#include <cstdint>
-#include <iostream>
-#include <iomanip>
-#include <chrono>
-#include <fstream>
-#include <string_view>
-#include <string>
-
-using namespace std::chrono_literals;
-
-static void print_time( std::chrono::steady_clock::time_point & t1, char const* label, std::size_t s, std::size_t size )
-{
-    auto t2 = std::chrono::steady_clock::now();
-
-    std::cout << label << ": " << ( t2 - t1 ) / 1ms << " ms (s=" << s << ", size=" << size << ")\n";
-
-    t1 = t2;
-}
-
-static std::vector<std::string> words;
-
-static void init_words()
-{
-#if SIZE_MAX > UINT32_MAX
-
-    char const* fn = "enwik9"; // http://mattmahoney.net/dc/textdata
-
-#else
-
-    char const* fn = "enwik8"; // ditto
-
-#endif
-
-    auto t1 = std::chrono::steady_clock::now();
-
-    std::ifstream is( fn );
-    std::string in( std::istreambuf_iterator<char>( is ), std::istreambuf_iterator<char>{} );
-
-    boost::regex re( "[a-zA-Z]+");
-    boost::sregex_token_iterator it( in.begin(), in.end(), re, 0 ), end;
-
-    words.assign( it, end );
-
-    auto t2 = std::chrono::steady_clock::now();
-
-    std::cout << fn << ": " << words.size() << " words, " << ( t2 - t1 ) / 1ms << " ms\n\n";
-}
-
-template<class Map> BOOST_NOINLINE void test_word_count( Map& map, std::chrono::steady_clock::time_point & t1 )
-{
-    std::size_t s = 0;
-
-    for( auto const& word: words )
-    {
-        ++map[ word ];
-        ++s;
-    }
-
-    print_time( t1, "Word count", s, map.size() );
-
-    std::cout << std::endl;
-}
-
-template<class Map> BOOST_NOINLINE void test_contains( Map& map, std::chrono::steady_clock::time_point & t1 )
-{
-    std::size_t s = 0;
-
-    for( auto const& word: words )
-    {
-        std::string_view w2( word );
-        w2.remove_prefix( 1 );
-
-        s += map.contains( w2 );
-    }
-
-    print_time( t1, "Contains", s, map.size() );
-
-    std::cout << std::endl;
-}
-
-template<class Map> BOOST_NOINLINE void test_count( Map& map, std::chrono::steady_clock::time_point & t1 )
-{
-    std::size_t s = 0;
-
-    for( auto const& word: words )
-    {
-        std::string_view w2( word );
-        w2.remove_prefix( 1 );
-
-        s += map.count( w2 );
-    }
-
-    print_time( t1, "Count", s, map.size() );
-
-    std::cout << std::endl;
-}
-
-template<class Map> BOOST_NOINLINE void test_iteration( Map& map, std::chrono::steady_clock::time_point & t1 )
-{
-    std::size_t max = 0;
-    std::string_view word;
-
-    for( auto const& x: map )
-    {
-        if( x.second > max )
-        {
-            word = x.first;
-            max = x.second;
-        }
-    }
-
-    print_time( t1, "Iterate and find max element",  max, map.size() );
-
-    std::cout << std::endl;
-}
-
-// counting allocator
-
-static std::size_t s_alloc_bytes = 0;
-static std::size_t s_alloc_count = 0;
-
-template<class T> struct allocator
-{
-    using value_type = T;
-
-    allocator() = default;
-
-    template<class U> allocator( allocator<U> const & ) noexcept
-    {
-    }
-
-    template<class U> bool operator==( allocator<U> const & ) const noexcept
-    {
-        return true;
-    }
-
-    template<class U> bool operator!=( allocator<U> const& ) const noexcept
-    {
-        return false;
-    }
-
-    T* allocate( std::size_t n ) const
-    {
-        s_alloc_bytes += n * sizeof(T);
-        s_alloc_count++;
-
-        return std::allocator<T>().allocate( n );
-    }
-
-    void deallocate( T* p, std::size_t n ) const noexcept
-    {
-        s_alloc_bytes -= n * sizeof(T);
-        s_alloc_count--;
-
-        std::allocator<T>().deallocate( p, n );
-    }
-};
-
-//
-
-struct record
-{
-    std::string label_;
-    long long time_;
-    std::size_t bytes_;
-    std::size_t count_;
-};
-
-static std::vector<record> times;
-
-template<template<class...> class Map> BOOST_NOINLINE void test( char const* label )
-{
-    std::cout << label << ":\n\n";
-
-    s_alloc_bytes = 0;
-    s_alloc_count = 0;
-
-    Map<std::string_view, std::size_t> map;
-
-    auto t0 = std::chrono::steady_clock::now();
-    auto t1 = t0;
-
-    test_word_count( map, t1 );
-
-    std::cout << "Memory: " << s_alloc_bytes << " bytes in " << s_alloc_count << " allocations\n\n";
-
-    record rec = { label, 0, s_alloc_bytes, s_alloc_count };
-
-    test_contains( map, t1 );
-    test_count( map, t1 );
-    test_iteration( map, t1 );
-
-    auto tN = std::chrono::steady_clock::now();
-    std::cout << "Total: " << ( tN - t0 ) / 1ms << " ms\n\n";
-
-    rec.time_ = ( tN - t0 ) / 1ms;
-    times.push_back( rec );
-}
-
-// aliases using the counting allocator
-
-template<class K, class V> using allocator_for = ::allocator< std::pair<K const, V> >;
-
-template<class K, class V> using std_unordered_map =
-    std::unordered_map<K, V, std::hash<K>, std::equal_to<K>, allocator_for<K, V>>;
-
-template<class K, class V> using boost_unordered_map =
-    boost::unordered_map<K, V, boost::hash<K>, std::equal_to<K>, allocator_for<K, V>>;
-
-template<class K, class V> using boost_unordered_flat_map =
-    boost::unordered_flat_map<K, V, boost::hash<K>, std::equal_to<K>, allocator_for<K, V>>;
-
-#ifdef HAVE_ABSEIL
-
-template<class K, class V> using absl_node_hash_map =
-    absl::node_hash_map<K, V, absl::container_internal::hash_default_hash<K>, absl::container_internal::hash_default_eq<K>, allocator_for<K, V>>;
-
-template<class K, class V> using absl_flat_hash_map =
-    absl::flat_hash_map<K, V, absl::container_internal::hash_default_hash<K>, absl::container_internal::hash_default_eq<K>, allocator_for<K, V>>;
-
-#endif
-
-#ifdef HAVE_ANKERL_UNORDERED_DENSE
-
-template<class K, class V> using ankerl_unordered_dense_map =
-    ankerl::unordered_dense::map<K, V, ankerl::unordered_dense::hash<K>, std::equal_to<K>, ::allocator< std::pair<K, V> >>;
-
-#endif
-
-// fnv1a_hash
-
-template<int Bits> struct fnv1a_hash_impl;
-
-template<> struct fnv1a_hash_impl<32>
-{
-    std::size_t operator()( std::string_view const& s ) const
-    {
-        std::size_t h = 0x811C9DC5u;
-
-        char const * first = s.data();
-        char const * last = first + s.size();
-
-        for( ; first != last; ++first )
-        {
-            h ^= static_cast<unsigned char>( *first );
-            h *= 0x01000193ul;
-        }
-
-        return h;
-    }
-};
-
-template<> struct fnv1a_hash_impl<64>
-{
-    std::size_t operator()( std::string_view const& s ) const
-    {
-        std::size_t h = 0xCBF29CE484222325ull;
-
-        char const * first = s.data();
-        char const * last = first + s.size();
-
-        for( ; first != last; ++first )
-        {
-            h ^= static_cast<unsigned char>( *first );
-            h *= 0x00000100000001B3ull;
-        }
-
-        return h;
-    }
-};
-
-struct fnv1a_hash: fnv1a_hash_impl< std::numeric_limits<std::size_t>::digits >
-{
-    using is_avalanching = void;
-};
-
-template<class K, class V> using std_unordered_map_fnv1a =
-std::unordered_map<K, V, fnv1a_hash, std::equal_to<K>, allocator_for<K, V>>;
-
-template<class K, class V> using boost_unordered_map_fnv1a =
-    boost::unordered_map<K, V, fnv1a_hash, std::equal_to<K>, allocator_for<K, V>>;
-
-template<class K, class V> using boost_unordered_flat_map_fnv1a =
-    boost::unordered_flat_map<K, V, fnv1a_hash, std::equal_to<K>, allocator_for<K, V>>;
-
-#ifdef HAVE_ABSEIL
-
-template<class K, class V> using absl_node_hash_map_fnv1a =
-    absl::node_hash_map<K, V, fnv1a_hash, absl::container_internal::hash_default_eq<K>, allocator_for<K, V>>;
-
-template<class K, class V> using absl_flat_hash_map_fnv1a =
-    absl::flat_hash_map<K, V, fnv1a_hash, absl::container_internal::hash_default_eq<K>, allocator_for<K, V>>;
-
-#endif
-
-#ifdef HAVE_ANKERL_UNORDERED_DENSE
-
-template<class K, class V> using ankerl_unordered_dense_map_fnv1a =
-    ankerl::unordered_dense::map<K, V, fnv1a_hash, std::equal_to<K>, ::allocator< std::pair<K, V> >>;
-
-#endif
-
-//
-
-int main()
-{
-    init_words();
-
-    test<std_unordered_map>( "std::unordered_map" );
-    test<boost_unordered_map>( "boost::unordered_map" );
-    test<boost_unordered_flat_map>( "boost::unordered_flat_map" );
-
-#ifdef HAVE_ANKERL_UNORDERED_DENSE
-
-    test<ankerl_unordered_dense_map>( "ankerl::unordered_dense::map" );
-
-#endif
-
-#ifdef HAVE_ABSEIL
-
-    test<absl_node_hash_map>( "absl::node_hash_map" );
-    test<absl_flat_hash_map>( "absl::flat_hash_map" );
-
-#endif
-
-    test<std_unordered_map_fnv1a>( "std::unordered_map, FNV-1a" );
-    test<boost_unordered_map_fnv1a>( "boost::unordered_map, FNV-1a" );
-    test<boost_unordered_flat_map_fnv1a>( "boost::unordered_flat_map, FNV-1a" );
-
-#ifdef HAVE_ANKERL_UNORDERED_DENSE
-
-    test<ankerl_unordered_dense_map_fnv1a>( "ankerl::unordered_dense::map, FNV-1a" );
-
-#endif
-
-#ifdef HAVE_ABSEIL
-
-    test<absl_node_hash_map_fnv1a>( "absl::node_hash_map, FNV-1a" );
-    test<absl_flat_hash_map_fnv1a>( "absl::flat_hash_map, FNV-1a" );
-
-#endif
-
-    std::cout << "---\n\n";
-
-    for( auto const& x: times )
-    {
-        std::cout << std::setw( 38 ) << ( x.label_ + ": " ) << std::setw( 5 ) << x.time_ << " ms, " << std::setw( 9 ) << x.bytes_ << " bytes in " << x.count_ << " allocations\n";
-    }
-}
-
-#ifdef HAVE_ABSEIL
-# include "absl/container/internal/raw_hash_set.cc"
-# include "absl/hash/internal/hash.cc"
-# include "absl/hash/internal/low_level_hash.cc"
-# include "absl/hash/internal/city.cc"
-#endif
@@ -1,255 +0,0 @@
-// Copyright 2021, 2022 Peter Dimov.
-// Distributed under the Boost Software License, Version 1.0.
-// https://www.boost.org/LICENSE_1_0.txt
-
-#define _SILENCE_CXX17_OLD_ALLOCATOR_MEMBERS_DEPRECATION_WARNING
-#define _SILENCE_CXX20_CISO646_REMOVED_WARNING
-
-#include <boost/unordered_map.hpp>
-#include <boost/unordered/unordered_flat_map.hpp>
-#include <boost/regex.hpp>
-#ifdef HAVE_ABSEIL
-# include "absl/container/node_hash_map.h"
-# include "absl/container/flat_hash_map.h"
-#endif
-#ifdef HAVE_ANKERL_UNORDERED_DENSE
-# include "ankerl/unordered_dense.h"
-#endif
-#include <unordered_map>
-#include <vector>
-#include <memory>
-#include <cstdint>
-#include <iostream>
-#include <iomanip>
-#include <chrono>
-#include <fstream>
-
-using namespace std::chrono_literals;
-
-static void print_time( std::chrono::steady_clock::time_point & t1, char const* label, std::size_t s, std::size_t size )
-{
-    auto t2 = std::chrono::steady_clock::now();
-
-    std::cout << label << ": " << ( t2 - t1 ) / 1ms << " ms (s=" << s << ", size=" << size << ")\n";
-
-    t1 = t2;
-}
-
-static std::vector<std::string> words;
-
-static void init_words()
-{
-#if SIZE_MAX > UINT32_MAX
-
-    char const* fn = "enwik9"; // http://mattmahoney.net/dc/textdata
-
-#else
-
-    char const* fn = "enwik8"; // ditto
-
-#endif
-
-    auto t1 = std::chrono::steady_clock::now();
-
-    std::ifstream is( fn );
-    std::string in( std::istreambuf_iterator<char>( is ), std::istreambuf_iterator<char>{} );
-
-    boost::regex re( "[a-zA-Z]+");
-    boost::sregex_token_iterator it( in.begin(), in.end(), re, 0 ), end;
-
-    words.assign( it, end );
-
-    auto t2 = std::chrono::steady_clock::now();
-
-    std::cout << fn << ": " << words.size() << " words, " << ( t2 - t1 ) / 1ms << " ms\n\n";
-}
-
-template<class Map> BOOST_NOINLINE void test_word_size( Map& map, std::chrono::steady_clock::time_point & t1 )
-{
-    for( auto const& word: words )
-    {
-        ++map[ word.size() ];
-    }
-
-    print_time( t1, "Word size count",  0, map.size() );
-
-    std::cout << std::endl;
-}
-
-template<class Map> BOOST_NOINLINE void test_iteration( Map& map, std::chrono::steady_clock::time_point & t1 )
-{
-    std::size_t s = 0;
-
-    for( auto const& x: map )
-    {
-        s += x.second;
-    }
-
-    print_time( t1, "Iterate and sum counts",  s, map.size() );
-
-    std::cout << std::endl;
-}
-
-// counting allocator
-
-static std::size_t s_alloc_bytes = 0;
-static std::size_t s_alloc_count = 0;
-
-template<class T> struct allocator
-{
-    using value_type = T;
-
-    allocator() = default;
-
-    template<class U> allocator( allocator<U> const & ) noexcept
-    {
-    }
-
-    template<class U> bool operator==( allocator<U> const & ) const noexcept
-    {
-        return true;
-    }
-
-    template<class U> bool operator!=( allocator<U> const& ) const noexcept
-    {
-        return false;
-    }
-
-    T* allocate( std::size_t n ) const
-    {
-        s_alloc_bytes += n * sizeof(T);
-        s_alloc_count++;
-
-        return std::allocator<T>().allocate( n );
-    }
-
-    void deallocate( T* p, std::size_t n ) const noexcept
-    {
-        s_alloc_bytes -= n * sizeof(T);
-        s_alloc_count--;
-
-        std::allocator<T>().deallocate( p, n );
-    }
-};
-
-//
-
-struct record
-{
-    std::string label_;
-    long long time_;
-    std::size_t bytes_;
-    std::size_t count_;
-};
-
-static std::vector<record> times;
-
-template<template<class...> class Map> BOOST_NOINLINE void test( char const* label )
-{
-    std::cout << label << ":\n\n";
-
-    s_alloc_bytes = 0;
-    s_alloc_count = 0;
-
-    Map<std::size_t, std::size_t> map;
-
-    auto t0 = std::chrono::steady_clock::now();
-    auto t1 = t0;
-
-    test_word_size( map, t1 );
-
-    std::cout << "Memory: " << s_alloc_bytes << " bytes in " << s_alloc_count << " allocations\n\n";
-
-    record rec = { label, 0, s_alloc_bytes, s_alloc_count };
-
-    test_iteration( map, t1 );
-
-    auto tN = std::chrono::steady_clock::now();
-    std::cout << "Total: " << ( tN - t0 ) / 1ms << " ms\n\n";
-
-    rec.time_ = ( tN - t0 ) / 1ms;
-    times.push_back( rec );
-}
-
-// aliases using the counting allocator
-
-template<class K, class V> using allocator_for = ::allocator< std::pair<K const, V> >;
-
-template<class K, class V> using std_unordered_map =
-    std::unordered_map<K, V, std::hash<K>, std::equal_to<K>, allocator_for<K, V>>;
-
-template<class K, class V> using boost_unordered_map =
-    boost::unordered_map<K, V, boost::hash<K>, std::equal_to<K>, allocator_for<K, V>>;
-
-template<class K, class V> using boost_unordered_flat_map_xmx =
-    boost::unordered_flat_map<K, V, boost::hash<K>, std::equal_to<K>, allocator_for<K, V>, boost::unordered::detail::foa::xmx_mix>;
-
-template<class K, class V> using boost_unordered_flat_map_xmx2 =
-    boost::unordered_flat_map<K, V, boost::hash<K>, std::equal_to<K>, allocator_for<K, V>, boost::unordered::detail::foa::xmx2_mix>;
-
-template<class K, class V> using boost_unordered_flat_map_xmx3 =
-    boost::unordered_flat_map<K, V, boost::hash<K>, std::equal_to<K>, allocator_for<K, V>, boost::unordered::detail::foa::xmx3_mix>;
-
-template<class K, class V> using boost_unordered_flat_map_mulx =
-    boost::unordered_flat_map<K, V, boost::hash<K>, std::equal_to<K>, allocator_for<K, V>, boost::unordered::detail::foa::mulx_mix>;
-
-template<class K, class V> using boost_unordered_flat_map_mulx2 =
-    boost::unordered_flat_map<K, V, boost::hash<K>, std::equal_to<K>, allocator_for<K, V>, boost::unordered::detail::foa::mulx2_mix>;
-
-#ifdef HAVE_ABSEIL
-
-template<class K, class V> using absl_node_hash_map =
-    absl::node_hash_map<K, V, absl::container_internal::hash_default_hash<K>, absl::container_internal::hash_default_eq<K>, allocator_for<K, V>>;
-
-template<class K, class V> using absl_flat_hash_map =
-    absl::flat_hash_map<K, V, absl::container_internal::hash_default_hash<K>, absl::container_internal::hash_default_eq<K>, allocator_for<K, V>>;
-
-#endif
-
-#ifdef HAVE_ANKERL_UNORDERED_DENSE
-
-template<class K, class V> using ankerl_unordered_dense_map =
-    ankerl::unordered_dense::map<K, V, ankerl::unordered_dense::hash<K>, std::equal_to<K>, ::allocator< std::pair<K, V> >>;
-
-#endif
-
-int main()
-{
-    init_words();
-
-    test<std_unordered_map>( "std::unordered_map" );
-    test<boost_unordered_map>( "boost::unordered_map" );
-
-    test<boost_unordered_flat_map_xmx>( "boost::unordered_flat_map, xmx" );
-    test<boost_unordered_flat_map_xmx2>( "boost::unordered_flat_map, xmx2" );
-    test<boost_unordered_flat_map_xmx3>( "boost::unordered_flat_map, xmx3" );
-    test<boost_unordered_flat_map_mulx>( "boost::unordered_flat_map, mulx" );
-    test<boost_unordered_flat_map_mulx2>( "boost::unordered_flat_map, mulx2" );
-
-#ifdef HAVE_ANKERL_UNORDERED_DENSE
-
-    test<ankerl_unordered_dense_map>( "ankerl::unordered_dense::map" );
-
-#endif
-
-#ifdef HAVE_ABSEIL
-
-    test<absl_node_hash_map>( "absl::node_hash_map" );
-    test<absl_flat_hash_map>( "absl::flat_hash_map" );
-
-#endif
-
-    std::cout << "---\n\n";
-
-    for( auto const& x: times )
-    {
-        std::cout << std::setw( 34 ) << ( x.label_ + ": " ) << std::setw( 5 ) << x.time_ << " ms, " << std::setw( 9 ) << x.bytes_ << " bytes in " << x.count_ << " allocations\n";
-    }
-}
-
-#ifdef HAVE_ABSEIL
-# include "absl/container/internal/raw_hash_set.cc"
-# include "absl/hash/internal/hash.cc"
-# include "absl/hash/internal/low_level_hash.cc"
-# include "absl/hash/internal/city.cc"
-#endif
@@ -244,69 +244,4 @@ image::fca.png[align=center]

 Thus container-wide iteration is turned into traversing the non-empty bucket groups (an operation with constant time complexity) which reduces the time complexity back to `O(size())`. In total, a bucket group is only 4 words in size and it views `sizeof(std::size_t) * CHAR_BIT` buckets meaning that for all common implementations, there's only 4 bits of space overhead per bucket introduced by the bucket groups.

-A more detailed description of Boost.Unordered's closed-addressing implementation is
-given in an
-https://bannalia.blogspot.com/2022/06/advancing-state-of-art-for.html[external article].
-For more information on implementation rationale, read the
-xref:#rationale_boostunordered_multiset_and_boostunordered_multimap[corresponding section].
-
-== Open Addressing Implementation
-
-The diagram shows the basic internal layout of `boost::unordered_flat_map` and
-`boost:unordered_flat_set`.
-
-
-[#img-foa-layout]
-.Open-addressing layout used by Boost.Unordered.
-image::foa.png[align=center]
-
-As with all open-addressing containers, elements are stored directly in the bucket array.
-This array is logically divided into 2^_n_^ _groups_ of 15 elements each.
-In addition to the bucket array, there is an associated _metadata array_ with 2^_n_^
-16-byte words.
-
-[#img-foa-metadata]
-.Breakdown of a metadata word.
-image::foa-metadata.png[align=center]
-
-A metadata word is divided into 15 _h_~_i_~ bytes (one for each associated
-bucket), and an _overflow byte_ (_ofw_ in the diagram). The value of _h_~_i_~ is:
-
-  - 0 if the corresponding bucket is empty.
-  - 1 to encode a special empty bucket called a _sentinel_, which is used internally to
-  stop iteration when the container has been fully traversed.
-  - If the bucket is occupied, a _reduced hash value_ obtained from the hash value of
-  the element.
-
-When looking for an element with hash value _h_, SIMD technologies such as
-https://en.wikipedia.org/wiki/SSE2[SSE2] and
-https://en.wikipedia.org/wiki/ARM_architecture_family#Advanced_SIMD_(Neon)[Neon] allow us
-to very quickly inspect the full metadata word and look for the reduced value of _h_ among all the
-15 buckets with just a handful of CPU instructions: non-matching buckets can be
-readily discarded, and those whose reduced hash value matches need be inspected via full
-comparison with the corresponding element. If the looked-for element is not present,
-the overflow byte is inspected:
-
- If the bit in the position _h_ mod 8 is zero, lookup terminates (and the
-element is not present).
- If the bit is set to 1 (the group has been _overflowed_), further groups are
-checked using https://en.wikipedia.org/wiki/Quadratic_probing[_quadratic probing_], and
-the process is repeated.
-
-Insertion is algorithmically similar: empty buckets are located using SIMD,
-and when going past a full group its corresponding overflow bit is set to 1.
-
-In architectures without SIMD support, the logical layout stays the same, but the metadata
-word is codified using a technique we call _bit interleaving_: this layout allows us
-to emulate SIMD with reasonably good performance using only standard arithmetic and
-logical operations.
-
-[#img-foa-metadata-interleaving]
-.Bit-interleaved metadata word.
-image::foa-metadata-interleaving.png[align=center]
-
-A more detailed description of Boost.Unordered's open-addressing implementation is
-given in an
-https://bannalia.blogspot.com/2022/11/inside-boostunorderedflatmap.html[external article].
-For more information on implementation rationale, read the
-xref:#rationale_boostunordered_flat_set_and_boostunordered_flat_map[corresponding section].
+For more information on implementation rationale, read the <<Implementation Rationale, corresponding section>>.
@@ -10,8 +10,6 @@

 * Added fast containers `boost::unordered_flat_map` and `boost::unordered_flat_set`
  based on open addressing.
-* Added CTAD deduction guides for all containers.
-* Added missing constructors as specified in https://cplusplus.github.io/LWG/issue2713[LWG issue 2713].

 == Release 1.80.0 - Major update

@@ -98,8 +98,9 @@ namespace boost {
    xref:#unordered_flat_map_destructor[~unordered_flat_map]();
    unordered_flat_map& xref:#unordered_flat_map_copy_assignment[operator++=++](const unordered_flat_map& other);
    unordered_flat_map& xref:#unordered_flat_map_move_assignment[operator++=++](unordered_flat_map&& other)
-      noexcept(boost::allocator_traits<Allocator>::is_always_equal::value ||
-              boost::allocator_traits<Allocator>::propagate_on_container_move_assignment::value);
+      noexcept(boost::allocator_traits<Allocator>::is_always_equal::value &&
+               boost::is_nothrow_move_assignable_v<Hash> &&
+               boost::is_nothrow_move_assignable_v<Pred>);
    unordered_flat_map& xref:#unordered_flat_map_initializer_list_assignment[operator++=++](std::initializer_list<value_type>);
    allocator_type xref:#unordered_flat_map_get_allocator[get_allocator]() const noexcept;

@@ -153,8 +154,9 @@ namespace boost {
    template<class K> size_type xref:#unordered_flat_map_transparent_erase_by_key[erase](K&& k);
    iterator  xref:#unordered_flat_map_erase_range[erase](const_iterator first, const_iterator last);
    void      xref:#unordered_flat_map_swap[swap](unordered_flat_map& other)
-      noexcept(boost::allocator_traits<Allocator>::is_always_equal::value ||
-               boost::allocator_traits<Allocator>::propagate_on_container_swap::value);
+      noexcept(boost::allocator_traits<Allocator>::is_always_equal::value &&
+               boost::is_nothrow_swappable_v<Hash> &&
+               boost::is_nothrow_swappable_v<Pred>);
    void      xref:#unordered_flat_map_clear[clear]() noexcept;

    template<class H2, class P2>
@@ -604,10 +606,11 @@ Requires:;; `value_type` is https://en.cppreference.com/w/cpp/named_req/CopyInse
 ==== Move Assignment
 ```c++
 unordered_flat_map& operator=(unordered_flat_map&& other)
-  noexcept(boost::allocator_traits<Allocator>::is_always_equal::value ||
-           boost::allocator_traits<Allocator>::propagate_on_container_move_assignment::value);
+  noexcept(boost::allocator_traits<Allocator>::is_always_equal::value &&
+           boost::is_nothrow_move_assignable_v<Hash> &&
+           boost::is_nothrow_move_assignable_v<Pred>);
 ```
-The move assignment operator. Destroys previously existing elements, swaps the hash function and predicate from `other`,
+The move assignment operator. Destroys previously existing elements, move-assigns the hash function and predicate from `other`,
 and move-assigns the allocator from `other` if `Alloc::propagate_on_container_move_assignment` exists and `Alloc::propagate_on_container_move_assignment::value` is `true`.
 If at this point the allocator is equal to `other.get_allocator()`, the internal bucket array of `other` is transferred directly to the new container;
 otherwise, inserts move-constructed copies of the elements of `other`.
@@ -1040,8 +1043,9 @@ Throws:;; Nothing in this implementation (neither the `hasher` nor the `key_equa
 ==== swap
 ```c++
 void swap(unordered_flat_map& other)
-  noexcept(boost::allocator_traits<Allocator>::is_always_equal::value ||
-           boost::allocator_traits<Allocator>::propagate_on_container_swap::value);
+  noexcept(boost::allocator_traits<Allocator>::is_always_equal::value &&
+           boost::is_nothrow_swappable_v<Hash> &&
+           boost::is_nothrow_swappable_v<Pred>);
 ```

 Swaps the contents of the container with the parameter.
@@ -93,8 +93,9 @@ namespace boost {
    xref:#unordered_flat_set_destructor[~unordered_flat_set]();
    unordered_flat_set& xref:#unordered_flat_set_copy_assignment[operator++=++](const unordered_flat_set& other);
    unordered_flat_set& xref:#unordered_flat_set_move_assignment[operator++=++](unordered_flat_set&& other)
-      noexcept(boost::allocator_traits<Allocator>::is_always_equal::value ||
-               boost::allocator_traits<Allocator>::propagate_on_container_move_assignment::value);
+      noexcept(boost::allocator_traits<Allocator>::is_always_equal::value &&
+               boost::is_nothrow_move_assignable_v<Hash> &&
+               boost::is_nothrow_move_assignable_v<Pred>);
    unordered_flat_set& xref:#unordered_flat_set_initializer_list_assignment[operator++=++](std::initializer_list<value_type>);
    allocator_type xref:#unordered_flat_set_get_allocator[get_allocator]() const noexcept;

@@ -127,8 +128,9 @@ namespace boost {
    template<class K> size_type xref:#unordered_flat_set_transparent_erase_by_key[erase](K&& k);
    iterator  xref:#unordered_flat_set_erase_range[erase](const_iterator first, const_iterator last);
    void      xref:#unordered_flat_set_swap[swap](unordered_flat_set& other)
-      noexcept(boost::allocator_traits<Allocator>::is_always_equal::value ||
-               boost::allocator_traits<Allocator>::propagate_on_container_swap::value);
+      noexcept(boost::allocator_traits<Allocator>::is_always_equal::value &&
+               boost::is_nothrow_swappable_v<Hash> &&
+               boost::is_nothrow_swappable_v<Pred>);
    void      xref:#unordered_flat_set_clear[clear]() noexcept;

    template<class H2, class P2>
@@ -563,10 +565,11 @@ Requires:;; `value_type` is https://en.cppreference.com/w/cpp/named_req/CopyInse
 ==== Move Assignment
 ```c++
 unordered_flat_set& operator=(unordered_flat_set&& other)
-  noexcept(boost::allocator_traits<Allocator>::is_always_equal::value ||
-           boost::allocator_traits<Allocator>::propagate_on_container_move_assignment::value);
+  noexcept(boost::allocator_traits<Allocator>::is_always_equal::value &&
+           boost::is_nothrow_move_assignable_v<Hash> &&
+           boost::is_nothrow_move_assignable_v<Pred>);
 ```
-The move assignment operator. Destroys previously existing elements, swaps the hash function and predicate from `other`,
+The move assignment operator. Destroys previously existing elements, move-assigns the hash function and predicate from `other`,
 and move-assigns the allocator from `other` if `Alloc::propagate_on_container_move_assignment` exists and `Alloc::propagate_on_container_move_assignment::value` is `true`.
 If at this point the allocator is equal to `other.get_allocator()`, the internal bucket array of `other` is transferred directly to the new container;
 otherwise, inserts move-constructed copies of the elements of `other`.
@@ -860,8 +863,9 @@ Throws:;; Nothing in this implementation (neither the `hasher` nor the `key_equa
 ==== swap
 ```c++
 void swap(unordered_flat_set& other)
-  noexcept(boost::allocator_traits<Allocator>::is_always_equal::value ||
-           boost::allocator_traits<Allocator>::propagate_on_container_swap::value);
+  noexcept(boost::allocator_traits<Allocator>::is_always_equal::value &&
+           boost::is_nothrow_swappable_v<Hash> &&
+           boost::is_nothrow_swappable_v<Pred>);
 ```

 Swaps the contents of the container with the parameter.
@@ -21,10 +21,8 @@
 #include <boost/core/pointer_traits.hpp>
 #include <boost/cstdint.hpp>
 #include <boost/predef.h>
-#include <boost/type_traits/has_trivial_copy.hpp>
 #include <boost/type_traits/is_nothrow_swappable.hpp>
 #include <boost/unordered/detail/xmx.hpp>
-#include <boost/unordered/detail/mulx.hpp>
 #include <boost/unordered/hash_traits.hpp>
 #include <climits>
 #include <cmath>
@@ -32,7 +30,6 @@
 #include <cstring>
 #include <iterator>
 #include <limits>
-#include <memory>
 #include <tuple>
 #include <type_traits>
 #include <utility>
@@ -70,12 +67,6 @@
  }while(0)
 #endif

-#define BOOST_UNORDERED_STATIC_ASSERT_HASH_PRED(Hash, Pred)                    \
-  static_assert(boost::is_nothrow_swappable<Hash>::value,                      \
-    "Template parameter Hash is required to be nothrow Swappable.");           \
-  static_assert(boost::is_nothrow_swappable<Pred>::value,                      \
-    "Template parameter Pred is required to be nothrow Swappable");
-
 namespace boost{
 namespace unordered{
 namespace detail{
@@ -270,20 +261,12 @@ private:
      0xF8F8F8F8u,0xF9F9F9F9u,0xFAFAFAFAu,0xFBFBFBFBu,0xFCFCFCFCu,0xFDFDFDFDu,0xFEFEFEFEu,0xFFFFFFFFu,
    };

-#if defined(__MSVC_RUNTIME_CHECKS)
-    return (int)word[hash&0xffu];
-#else
    return (int)word[(unsigned char)hash];
-#endif
  }

  inline static unsigned char reduced_hash(std::size_t hash)
  {
-#if defined(__MSVC_RUNTIME_CHECKS)
-    return match_word(hash)&0xffu;
-#else
    return (unsigned char)match_word(hash);
-#endif
  }

  inline unsigned char& at(std::size_t pos)
@@ -534,11 +517,7 @@ struct group15
    std::size_t     pos=reinterpret_cast<uintptr_t>(pc)%sizeof(group15);
    group15        *pg=reinterpret_cast<group15*>(pc-pos);
    boost::uint64_t x=((pg->m[0])>>pos)&0x000100010001ull;
-#if defined(__MSVC_RUNTIME_CHECKS)
-    boost::uint32_t y=(x|(x>>15)|(x>>30))&0xffffffffu;
-#else
    boost::uint32_t y=static_cast<boost::uint32_t>(x|(x>>15)|(x>>30));
-#endif
    return !pg->is_not_overflowed(y);
  };

@@ -553,11 +532,7 @@ struct group15
  inline int match_occupied()const
  {
    boost::uint64_t x=m[0]|m[1];
-#if defined(__MSVC_RUNTIME_CHECKS)
-    boost::uint32_t y=(x|(x>>32))&0xffffffffu;
-#else
    boost::uint32_t y=static_cast<boost::uint32_t>(x|(x>>32));
-#endif
    y|=y>>16;
    return y&0x7FFF;
  }
@@ -592,11 +567,7 @@ private:
      240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255,
    };
    
-#if defined(__MSVC_RUNTIME_CHECKS)
-  return table[hash&0xffu];
-#else
    return table[(unsigned char)hash];
-#endif
  }

  inline void set_impl(std::size_t pos,std::size_t n)
@@ -685,6 +656,7 @@ private:
 *     these values and positioning to be as uncorrelated as possible.
 */

+#if 0
 struct pow2_size_policy
 {
  static inline std::size_t size_index(std::size_t n)
@@ -708,6 +680,47 @@ struct pow2_size_policy
    return hash>>size_index_;
  }
 };
+#else
+struct pow2_size_policy
+{
+  static inline std::size_t size_index(std::size_t n)
+  {
+    // TODO: min size is 2, see if we can bring it down to 1 without loss
+    // of performance
+
+    std::size_t used_bits_=n<=2?1:((std::size_t)(boost::core::bit_width(n-1)));
+    std::size_t shift_right_=total_bits-used_bits_;
+    std::size_t shift_left_=shift_right_%2?0:shift_right_-8;
+
+    return (shift_left_<<16)|shift_right_;
+  }
+
+  static inline std::size_t size(std::size_t size_index_)
+  {
+    return std::size_t(1)<<(total_bits-shift_right(size_index_));
+  }
+    
+  static constexpr std::size_t min_size(){return 2;}
+
+  static inline std::size_t position(std::size_t hash,std::size_t size_index_)
+  {
+    return (hash<<shift_left(size_index_))>>shift_right(size_index_);
+  }
+
+private:
+  static constexpr std::size_t total_bits=sizeof(std::size_t)*CHAR_BIT;
+
+  static inline std::size_t shift_left(std::size_t size_index_)
+  {
+    return size_index_>>16;
+  }
+
+  static inline std::size_t shift_right(std::size_t size_index_)
+  {
+    return size_index_&0xffffu;
+  }
+};
+#endif

 /* size index of a group array for a given *element* capacity */

@@ -769,42 +782,6 @@ struct xmx_mix
  }
 };

-struct xmx2_mix
-{
-  template<typename Hash,typename T>
-  static inline std::size_t mix(const Hash& h,const T& x)
-  {
-    return xmx2(h(x));
-  }
-};
-
-struct xmx3_mix
-{
-  template<typename Hash,typename T>
-  static inline std::size_t mix(const Hash& h,const T& x)
-  {
-    return xmx3(h(x));
-  }
-};
-
-struct mulx_mix
-{
-  template<typename Hash,typename T>
-  static inline std::size_t mix(const Hash& h,const T& x)
-  {
-    return mulx(h(x));
-  }
-};
-
-struct mulx2_mix
-{
-  template<typename Hash,typename T>
-  static inline std::size_t mix(const Hash& h,const T& x)
-  {
-    return mulx2(h(x));
-  }
-};
-
 /* boost::core::countr_zero has a potentially costly check for
 * the case x==0.
 */
@@ -821,7 +798,7 @@ inline unsigned int unchecked_countr_zero(int x)
 #endif
 }

-template<typename,typename,typename,typename,typename>
+template<typename,typename,typename,typename>
 class table;

 /* table_iterator keeps two pointers:
@@ -885,7 +862,7 @@ public:

 private:
  template<typename,typename,bool> friend class table_iterator;
-  template<typename,typename,typename,typename,typename> friend class table;
+  template<typename,typename,typename,typename> friend class table;

  table_iterator(Group* pg,std::size_t n,const Value* p_):
    pc{reinterpret_cast<unsigned char*>(const_cast<Group*>(pg))+n},
@@ -1059,7 +1036,6 @@ void swap_if(T&,T&){}

 inline void prefetch(const void* p)
 {
-  (void) p;
 #if defined(BOOST_GCC)||defined(BOOST_CLANG)
  __builtin_prefetch((const char*)p);
 #elif defined(BOOST_UNORDERED_SSE2)
@@ -1067,49 +1043,6 @@ inline void prefetch(const void* p)
 #endif    
 }

-struct try_emplace_args_t{};
-
-template<typename Allocator>
-struct is_std_allocator:std::false_type{};
-
-template<typename T>
-struct is_std_allocator<std::allocator<T>>:std::true_type{};
-
-/* std::allocator::construct marked as deprecated */
-#if defined(_LIBCPP_SUPPRESS_DEPRECATED_PUSH)
-_LIBCPP_SUPPRESS_DEPRECATED_PUSH
-#elif defined(_STL_DISABLE_DEPRECATED_WARNING)
-_STL_DISABLE_DEPRECATED_WARNING
-#elif defined(_MSC_VER)
-#pragma warning(push)
-#pragma warning(disable:4996)
-#endif
-
-template<typename Allocator,typename Ptr,typename... Args>
-struct alloc_has_construct
-{
-private:
-  template<typename Allocator2>
-  static decltype(
-    std::declval<Allocator2&>().construct(
-      std::declval<Ptr>(),std::declval<Args&&>()...),
-    std::true_type{}
-  ) check(int);
-
-  template<typename> static std::false_type check(...);
-
-public:
-  static constexpr bool value=decltype(check<Allocator>(0))::value;
-};
-
-#if defined(_LIBCPP_SUPPRESS_DEPRECATED_POP)
-_LIBCPP_SUPPRESS_DEPRECATED_POP
-#elif defined(_STL_RESTORE_DEPRECATED_WARNING)
-_STL_RESTORE_DEPRECATED_WARNING
-#elif defined(_MSC_VER)
-#pragma warning(pop)
-#endif
-
 #if defined(BOOST_GCC)
 /* GCC's -Wshadow triggers at scenarios like this: 
 *
@@ -1190,7 +1123,7 @@ _STL_RESTORE_DEPRECATED_WARNING
 */
 constexpr static float const mlf = 0.875f;

-template<typename TypePolicy,typename Hash,typename Pred,typename Allocator,typename MixPolicy=xmx_mix>
+template<typename TypePolicy,typename Hash,typename Pred,typename Allocator>
 class 

 #if defined(_MSC_VER)&&_MSC_FULL_VER>=190023918
@@ -1210,7 +1143,7 @@ table:empty_value<Hash,0>,empty_value<Pred,1>,empty_value<Allocator,2>
  using mix_policy=typename std::conditional<
    hash_is_avalanching<Hash>::value,
    no_mix,
-    MixPolicy
+    xmx_mix
  >::type;
  using alloc_traits=boost::allocator_traits<Allocator>;

@@ -1268,7 +1201,9 @@ public:
  table(const table& x,const Allocator& al_):
    table{std::size_t(std::ceil(float(x.size())/mlf)),x.h(),x.pred(),al_}
  {
-    copy_elements_from(x);
+    x.for_all_elements([this](value_type* p){
+      unchecked_insert(*p);
+    });
  }

  table(table&& x,const Allocator& al_):
@@ -1303,35 +1238,22 @@ public:

  table& operator=(const table& x)
  {
-    BOOST_UNORDERED_STATIC_ASSERT_HASH_PRED(Hash, Pred)
-
    static constexpr auto pocca=
      alloc_traits::propagate_on_container_copy_assignment::value;

    if(this!=std::addressof(x)){
-      // if copy construction here winds up throwing, the container is still
-      // left intact so we perform these operations first
-      hasher    tmp_h=x.h();
-      key_equal tmp_p=x.pred();
-
-      // already noexcept, clear() before we swap the Hash, Pred just in case
-      // the clear() impl relies on them at some point in the future
-      clear(); 
-
-      // because we've asserted at compile-time that Hash and Pred are nothrow
-      // swappable, we can safely mutate our source container and maintain
-      // consistency between the Hash, Pred compatibility
-      using std::swap;
-      swap(h(),tmp_h);
-      swap(pred(),tmp_p);
-
+      clear();
+      h()=x.h();
+      pred()=x.pred();
      if_constexpr<pocca>([&,this]{
        if(al()!=x.al())reserve(0);
        copy_assign_if<pocca>(al(),x.al());
      });
      /* noshrink: favor memory reuse over tightness */
-      noshrink_reserve(x.size());
-      copy_elements_from(x);
+      noshrink_reserve(x.size()); 
+      x.for_all_elements([this](value_type* p){
+        unchecked_insert(*p);
+      });
    }
    return *this;
  }
@@ -1343,32 +1265,19 @@ public:

  table& operator=(table&& x)
    noexcept(
-      alloc_traits::propagate_on_container_move_assignment::value||
-      alloc_traits::is_always_equal::value)
+      alloc_traits::is_always_equal::value&&
+      std::is_nothrow_move_assignable<Hash>::value&&
+      std::is_nothrow_move_assignable<Pred>::value)
  {
-    BOOST_UNORDERED_STATIC_ASSERT_HASH_PRED(Hash, Pred)
-
    static constexpr auto pocma=
      alloc_traits::propagate_on_container_move_assignment::value;

    if(this!=std::addressof(x)){
-      /* Given ambiguity in implementation strategies briefly discussed here:
-       * https://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#2227
-       *
-       * we opt into requiring nothrow swappability and eschew the move
-       * operations associated with Hash, Pred.
-       *
-       * To this end, we ensure that the user never has to consider the
-       * moved-from state of their Hash, Pred objects
-       */
-
-      using std::swap;
-
      clear();
-      swap(h(),x.h());
-      swap(pred(),x.pred());
-
+      h()=std::move(x.h());
+      pred()=std::move(x.pred());
      if(pocma||al()==x.al()){
+        using std::swap;
        reserve(0);
        move_assign_if<pocma>(al(),x.al());
        swap(size_,x.size_);
@@ -1431,10 +1340,12 @@ public:

  template<typename Key,typename... Args>
  BOOST_FORCEINLINE std::pair<iterator,bool> try_emplace(
-    Key&& x,Args&&... args)
+    Key&& k,Args&&... args)
  {
    return emplace_impl(
-      try_emplace_args_t{},std::forward<Key>(x),std::forward<Args>(args)...);
+      std::piecewise_construct,
+      std::forward_as_tuple(std::forward<Key>(k)),
+      std::forward_as_tuple(std::forward<Args>(args)...));
  }

  BOOST_FORCEINLINE std::pair<iterator,bool>
@@ -1483,15 +1394,16 @@ public:

  void swap(table& x)
    noexcept(
-      alloc_traits::propagate_on_container_swap::value||
-      alloc_traits::is_always_equal::value)
+      alloc_traits::is_always_equal::value&&
+      boost::is_nothrow_swappable<Hash>::value&&
+      boost::is_nothrow_swappable<Pred>::value)
  {
-    BOOST_UNORDERED_STATIC_ASSERT_HASH_PRED(Hash, Pred)
-
    static constexpr auto pocs=
      alloc_traits::propagate_on_container_swap::value;

    using std::swap;
+    swap(h(),x.h());
+    swap(pred(),x.pred());
    if_constexpr<pocs>([&,this]{
      swap_if<pocs>(al(),x.al());
    },
@@ -1499,9 +1411,6 @@ public:
      BOOST_ASSERT(al()==x.al());
      (void)this; /* makes sure captured this is used */
    });
-
-    swap(h(),x.h());
-    swap(pred(),x.pred());
    swap(size_,x.size_);
    swap(arrays,x.arrays);
    swap(ml,x.ml);
@@ -1593,7 +1502,7 @@ public:
  }

 private:
-  template<typename,typename,typename,typename,typename> friend class table;
+  template<typename,typename,typename,typename> friend class table;
  using arrays_type=table_arrays<value_type,group_type,size_policy>;

  struct clear_on_exit
@@ -1625,37 +1534,6 @@ private:
    alloc_traits::construct(al(),p,std::forward<Args>(args)...);
  }

-  template<typename... Args>
-  void construct_element(value_type* p,try_emplace_args_t,Args&&... args)
-  {
-    construct_element_from_try_emplace_args(
-      p,
-      std::integral_constant<bool,std::is_same<key_type,value_type>::value>{},
-      std::forward<Args>(args)...);
-  }
-
-  template<typename Key,typename... Args>
-  void construct_element_from_try_emplace_args(
-    value_type* p,std::false_type,Key&& x,Args&&... args)
-  {
-    alloc_traits::construct(
-      al(),p,
-      std::piecewise_construct,
-      std::forward_as_tuple(std::forward<Key>(x)),
-      std::forward_as_tuple(std::forward<Args>(args)...));
-  }
-
-  /* This overload allows boost::unordered_flat_set to internally use
-   * try_emplace to implement heterogeneous insert (P2363).
-   */
-
-  template<typename Key>
-  void construct_element_from_try_emplace_args(
-    value_type* p,std::true_type,Key&& x)
-  {
-    alloc_traits::construct(al(),p,std::forward<Key>(x));
-  }
-
  void destroy_element(value_type* p)noexcept
  {
    alloc_traits::destroy(al(),p);
@@ -1668,82 +1546,6 @@ private:
    value_type *p;
  };

-  void copy_elements_from(const table& x)
-  {
-    BOOST_ASSERT(empty());
-    BOOST_ASSERT(this!=std::addressof(x));
-    if(arrays.groups_size_mask==x.arrays.groups_size_mask){
-      fast_copy_elements_from(x);
-    }
-    else{
-      x.for_all_elements([this](const value_type* p){
-        unchecked_insert(*p);
-      });
-    }
-  }
-
-  void fast_copy_elements_from(const table& x)
-  {
-    if(arrays.elements){
-      copy_elements_array_from(x);
-      std::memcpy(
-        arrays.groups,x.arrays.groups,
-        (arrays.groups_size_mask+1)*sizeof(group_type));
-      size_=x.size();
-    }
-  }
-
-  void copy_elements_array_from(const table& x)
-  {
-    copy_elements_array_from(
-      x,
-      std::integral_constant<
-        bool,
-#if BOOST_WORKAROUND(BOOST_LIBSTDCXX_VERSION,<50000)
-        /* std::is_trivially_copy_constructible not provided */
-        boost::has_trivial_copy<value_type>::value
-#else
-        std::is_trivially_copy_constructible<value_type>::value
-#endif
-        &&(
-          is_std_allocator<Allocator>::value||
-          !alloc_has_construct<Allocator,value_type*,const value_type&>::value)
-      >{}
-    );
-  }
-
-  void copy_elements_array_from(const table& x,std::true_type /* -> memcpy */)
-  {
-    /* reinterpret_cast: GCC may complain about value_type not being trivially
-     * copy-assignable when we're relying on trivial copy constructibility.
-     */
-    std::memcpy(
-      reinterpret_cast<unsigned char*>(arrays.elements),
-      reinterpret_cast<unsigned char*>(x.arrays.elements),
-      x.capacity()*sizeof(value_type));
-  }
-
-  void copy_elements_array_from(const table& x,std::false_type /* -> manual */)
-  {
-    std::size_t num_constructed=0;
-    BOOST_TRY{
-      x.for_all_elements([&,this](const value_type* p){
-        construct_element(arrays.elements+(p-x.arrays.elements),*p);
-        ++num_constructed;
-      });
-    }
-    BOOST_CATCH(...){
-      if(num_constructed){
-        x.for_all_elements_while([&,this](const value_type* p){
-          destroy_element(arrays.elements+(p-x.arrays.elements));
-          return --num_constructed!=0;
-        });
-      }
-      BOOST_RETHROW
-    }
-    BOOST_CATCH_END
-  }
-
  void recover_slot(unsigned char* pc)
  {
    /* If this slot potentially caused overflow, we decrease the maximum load so
@@ -1780,11 +1582,12 @@ private:
    return type_policy::extract(x);
  }

-  template<typename Key,typename... Args>
-  static inline const Key& key_from(
-    try_emplace_args_t,const Key& x,const Args&...)
+  template<typename Arg1,typename Arg2>
+  static inline auto key_from(
+    std::piecewise_construct_t,const Arg1& k,const Arg2&)
+    ->decltype(std::get<0>(k))
  {
-    return x;
+    return std::get<0>(k);
  }

  template<typename Key>
@@ -1945,13 +1748,17 @@ private:
    }
    BOOST_CATCH(...){
      if(num_destroyed){
-        for_all_elements_while(
-          [&,this](group_type* pg,unsigned int n,value_type*){
-            recover_slot(pg,n);
-            return --num_destroyed!=0;
+        for(auto pg=arrays.groups;;++pg){
+          auto mask=pg->match_occupied();
+          while(mask){
+            auto nz=unchecked_countr_zero(mask);
+            recover_slot(pg,nz);
+            if(!(--num_destroyed))goto continue_;
+            mask&=mask-1;
          }
-        );
+        }
      }
+      continue_:
      for_all_elements(new_arrays_,[this](value_type* p){
        destroy_element(p);
      });
@@ -2081,34 +1888,12 @@ private:
  static auto for_all_elements(const arrays_type& arrays_,F f)
    ->decltype(f(nullptr),void())
  {
-    for_all_elements_while(arrays_,[&](value_type* p){f(p);return true;});
-  }
-
-  template<typename F>
-  static auto for_all_elements(const arrays_type& arrays_,F f)
-    ->decltype(f(nullptr,0,nullptr),void())
-  {
-    for_all_elements_while(
-      arrays_,[&](group_type* pg,unsigned int n,value_type* p)
-        {f(pg,n,p);return true;});
-  }
-
-  template<typename F>
-  void for_all_elements_while(F f)const
-  {
-    for_all_elements_while(arrays,f);
-  }
-
-  template<typename F>
-  static auto for_all_elements_while(const arrays_type& arrays_,F f)
-    ->decltype(f(nullptr),void())
-  {
-    for_all_elements_while(
+    for_all_elements(
      arrays_,[&](group_type*,unsigned int,value_type* p){return f(p);});
  }

  template<typename F>
-  static auto for_all_elements_while(const arrays_type& arrays_,F f)
+  static auto for_all_elements(const arrays_type& arrays_,F f)
    ->decltype(f(nullptr,0,nullptr),void())
  {
    auto p=arrays_.elements;
@@ -2118,7 +1903,7 @@ private:
      auto mask=pg->match_really_occupied();
      while(mask){
        auto n=unchecked_countr_zero(mask);
-        if(!f(pg,n,p+n))return;
+        f(pg,n,p+n);
        mask&=mask-1;
      }
    }
@@ -2148,7 +1933,6 @@ private:

 #undef BOOST_UNORDERED_ASSUME
 #undef BOOST_UNORDERED_HAS_BUILTIN
-#undef BOOST_UNORDERED_STATIC_ASSERT_HASH_PRED
 #ifdef BOOST_UNORDERED_LITTLE_ENDIAN_NEON
 #undef BOOST_UNORDERED_LITTLE_ENDIAN_NEON
 #endif
@@ -1,135 +0,0 @@
-#ifndef BOOST_UNORDERED_DETAIL_MULX_HPP
-#define BOOST_UNORDERED_DETAIL_MULX_HPP
-
-// Copyright 2022 Peter Dimov.
-// Copyright 2022 Joaquin M Lopez Munoz.
-// Distributed under the Boost Software License, Version 1.0.
-// https://www.boost.org/LICENSE_1_0.txt)
-
-#include <boost/cstdint.hpp>
-#include <climits>
-#include <cstddef>
-
-#if defined(_MSC_VER) && !defined(__clang__)
-# include <intrin.h>
-#endif
-
-namespace boost {
-namespace unordered {
-namespace detail {
-
-// Bit mixer based on the mulx primitive
-
-#if defined(_MSC_VER) && defined(_M_X64) && !defined(__clang__)
-
-__forceinline boost::uint64_t mulx64( boost::uint64_t x, boost::uint64_t y )
-{
-    boost::uint64_t r2;
-    boost::uint64_t r = _umul128( x, y, &r2 );
-    return r ^ r2;
-}
-
-#elif defined(_MSC_VER) && defined(_M_ARM64) && !defined(__clang__)
-
-__forceinline boost::uint64_t mulx64( boost::uint64_t x, boost::uint64_t y )
-{
-    boost::uint64_t r = x * y;
-    boost::uint64_t r2 = __umulh( x, y );
-    return r ^ r2;
-}
-
-#elif defined(__SIZEOF_INT128__)
-
-inline boost::uint64_t mulx64( boost::uint64_t x, boost::uint64_t y )
-{
-    __uint128_t r = (__uint128_t)x * y;
-    return (boost::uint64_t)r ^ (boost::uint64_t)( r >> 64 );
-}
-
-#else
-
-inline boost::uint64_t mulx64( boost::uint64_t x, boost::uint64_t y )
-{
-    boost::uint64_t x1 = (boost::uint32_t)x;
-    boost::uint64_t x2 = x >> 32;
-
-    boost::uint64_t y1 = (boost::uint32_t)y;
-    boost::uint64_t y2 = y >> 32;
-
-    boost::uint64_t r3 = x2 * y2;
-
-    boost::uint64_t r2a = x1 * y2;
-
-    r3 += r2a >> 32;
-
-    boost::uint64_t r2b = x2 * y1;
-
-    r3 += r2b >> 32;
-
-    boost::uint64_t r1 = x1 * y1;
-
-    boost::uint64_t r2 = (r1 >> 32) + (boost::uint32_t)r2a + (boost::uint32_t)r2b;
-
-    r1 = (r2 << 32) + (boost::uint32_t)r1;
-    r3 += r2 >> 32;
-
-    return r1 ^ r3;
-}
-
-#endif
-
-inline boost::uint32_t mulx32( boost::uint32_t x, boost::uint32_t y )
-{
-    boost::uint64_t r = (boost::uint64_t)x * y;
-    return (boost::uint32_t)r ^ (boost::uint32_t)(r >> 32);
-}
-
-#if defined(SIZE_MAX)
-#if ((((SIZE_MAX >> 16) >> 16) >> 16) >> 15) != 0
-#define BOOST_UNORDERED_64B_ARCHITECTURE /* >64 bits assumed as 64 bits */
-#endif
-#elif defined(UINTPTR_MAX) /* used as proxy for std::size_t */
-#if ((((UINTPTR_MAX >> 16) >> 16) >> 16) >> 15) != 0
-#define BOOST_UNORDERED_64B_ARCHITECTURE
-#endif
-#endif
-
-// phi multipliers
-
-inline std::size_t mulx( std::size_t x ) noexcept
-{
-#if defined(BOOST_UNORDERED_64B_ARCHITECTURE)
-
-    return (std::size_t)mulx64( (boost::uint64_t)x, 0x9E3779B97F4A7C15ull );
-
-#else /* 32 bits assumed */
-
-    return mulx32( x, 0x9E3779B9u );
-
-#endif
-}
-
-// multipliers from https://arxiv.org/abs/2001.05304
-
-inline std::size_t mulx2( std::size_t x ) noexcept
-{
-#if defined(BOOST_UNORDERED_64B_ARCHITECTURE)
-
-    return (std::size_t)mulx64( (boost::uint64_t)x, 0xDEFBA91144F2B375ull );
-
-#else /* 32 bits assumed */
-
-    return mulx32( x, 0xE817FB2Du );
-
-#endif
-}
-
-#ifdef BOOST_UNORDERED_64B_ARCHITECTURE
-#undef BOOST_UNORDERED_64B_ARCHITECTURE
-#endif
-
-} // namespace detail
-} // namespace unordered
-} // namespace boost
-
-#endif // #ifndef BOOST_UNORDERED_DETAIL_MULX_HPP
@@ -117,15 +117,9 @@ namespace boost {
 #if defined(BOOST_UNORDERED_FCA_HAS_64B_SIZE_T)
          std::size_t sizes_under_32bit = inv_sizes32_len;
          if (BOOST_LIKELY(size_index < sizes_under_32bit)) {
-#if defined(__MSVC_RUNTIME_CHECKS)
-            return fast_modulo(
-              boost::uint32_t(hash & 0xffffffffu) + boost::uint32_t(hash >> 32),
-              inv_sizes32[size_index], boost::uint32_t(sizes[size_index]));
-#else
            return fast_modulo(
              boost::uint32_t(hash) + boost::uint32_t(hash >> 32),
              inv_sizes32[size_index], boost::uint32_t(sizes[size_index]));
-#endif
          } else {
            return positions[size_index - sizes_under_32bit](hash);
          }
@@ -64,56 +64,6 @@ static inline std::size_t xmx(std::size_t x)noexcept
 #endif
 }

-// alternative multipliers (phi)
-
-static inline std::size_t xmx2( std::size_t x ) noexcept
-{
-#if defined(BOOST_UNORDERED_64B_ARCHITECTURE)
-
-  boost::uint64_t z=(boost::uint64_t)x;
-
-  z ^= z >> 23;
-  z *= 0x9E3779B97F4A7C15ull;
-  z ^= z >> 23;
-
-  return (std::size_t)z;
-
-#else /* 32 bits assumed */
-
-  x ^= x >> 18;
-  x *= 0x9E3779B9u;
-  x ^= x >> 16;
-
-  return x;
-
-#endif
-}
-
-// alternative multipliers (https://arxiv.org/abs/2001.05304)
-
-static inline std::size_t xmx3( std::size_t x ) noexcept
-{
-#if defined(BOOST_UNORDERED_64B_ARCHITECTURE)
-
-  boost::uint64_t z=(boost::uint64_t)x;
-
-  z ^= z >> 23;
-  z *= 0xF1357AEA2E62A9C5ull;
-  z ^= z >> 23;
-
-  return (std::size_t)z;
-
-#else /* 32 bits assumed */
-
-  x ^= x >> 18;
-  x *= 0x93D765DDu;
-  x ^= x >> 16;
-
-  return x;
-
-#endif
-}
-
 #ifdef BOOST_UNORDERED_64B_ARCHITECTURE
 #undef BOOST_UNORDERED_64B_ARCHITECTURE
 #endif
@@ -32,7 +32,7 @@ namespace boost {
 #pragma warning(disable : 4714) /* marked as __forceinline not inlined */
 #endif

-    template <class Key, class T, class Hash, class KeyEqual, class Allocator, class MixPolicy>
+    template <class Key, class T, class Hash, class KeyEqual, class Allocator>
    class unordered_flat_map
    {
      struct map_types
@@ -61,13 +61,13 @@ namespace boost {

      using table_type = detail::foa::table<map_types, Hash, KeyEqual,
        typename boost::allocator_rebind<Allocator,
-          typename map_types::value_type>::type, MixPolicy>;
+          typename map_types::value_type>::type>;

      table_type table_;

-      template <class K, class V, class H, class KE, class A, class MP, class Pred>
-      typename unordered_flat_map<K, V, H, KE, A, MP>::size_type friend erase_if(
-        unordered_flat_map<K, V, H, KE, A, MP>& set, Pred pred);
+      template <class K, class V, class H, class KE, class A, class Pred>
+      typename unordered_flat_map<K, V, H, KE, A>::size_type friend erase_if(
+        unordered_flat_map<K, V, H, KE, A>& set, Pred pred);

    public:
      using key_type = Key;
@@ -387,7 +387,7 @@ namespace boost {

      template <class H2, class P2>
      void merge(
-        unordered_flat_map<key_type, mapped_type, H2, P2, allocator_type, MixPolicy>&
+        unordered_flat_map<key_type, mapped_type, H2, P2, allocator_type>&
          source)
      {
        table_.merge(source.table_);
@@ -395,7 +395,7 @@ namespace boost {

      template <class H2, class P2>
      void merge(
-        unordered_flat_map<key_type, mapped_type, H2, P2, allocator_type, MixPolicy>&&
+        unordered_flat_map<key_type, mapped_type, H2, P2, allocator_type>&&
          source)
      {
        table_.merge(std::move(source.table_));
@@ -427,24 +427,24 @@ namespace boost {
          std::out_of_range("key was not found in unordered_flat_map"));
      }

-      BOOST_FORCEINLINE mapped_type& operator[](key_type const& key)
+      mapped_type& operator[](key_type const& key)
      {
        return table_.try_emplace(key).first->second;
      }

-      BOOST_FORCEINLINE mapped_type& operator[](key_type&& key)
+      mapped_type& operator[](key_type&& key)
      {
        return table_.try_emplace(std::move(key)).first->second;
      }

-      BOOST_FORCEINLINE size_type count(key_type const& key) const
+      size_type count(key_type const& key) const
      {
        auto pos = table_.find(key);
        return pos != table_.end() ? 1 : 0;
      }

      template <class K>
-      BOOST_FORCEINLINE typename std::enable_if<
+      typename std::enable_if<
        detail::are_transparent<K, hasher, key_equal>::value, size_type>::type
      count(K const& key) const
      {
@@ -480,13 +480,13 @@ namespace boost {
        return table_.find(key);
      }

-      BOOST_FORCEINLINE bool contains(key_type const& key) const
+      bool contains(key_type const& key) const
      {
        return this->find(key) != this->end();
      }

      template <class K>
-      BOOST_FORCEINLINE typename std::enable_if<
+      typename std::enable_if<
        boost::unordered::detail::are_transparent<K, hasher, key_equal>::value,
        bool>::type
      contains(K const& key) const
@@ -579,10 +579,10 @@ namespace boost {
      key_equal key_eq() const { return table_.key_eq(); }
    };

-    template <class Key, class T, class Hash, class KeyEqual, class Allocator, class MixPolicy>
+    template <class Key, class T, class Hash, class KeyEqual, class Allocator>
    bool operator==(
-      unordered_flat_map<Key, T, Hash, KeyEqual, Allocator, MixPolicy> const& lhs,
-      unordered_flat_map<Key, T, Hash, KeyEqual, Allocator, MixPolicy> const& rhs)
+      unordered_flat_map<Key, T, Hash, KeyEqual, Allocator> const& lhs,
+      unordered_flat_map<Key, T, Hash, KeyEqual, Allocator> const& rhs)
    {
      if (&lhs == &rhs) {
        return true;
@@ -599,27 +599,27 @@ namespace boost {
      })();
    }

-    template <class Key, class T, class Hash, class KeyEqual, class Allocator, class MixPolicy>
+    template <class Key, class T, class Hash, class KeyEqual, class Allocator>
    bool operator!=(
-      unordered_flat_map<Key, T, Hash, KeyEqual, Allocator, MixPolicy> const& lhs,
-      unordered_flat_map<Key, T, Hash, KeyEqual, Allocator, MixPolicy> const& rhs)
+      unordered_flat_map<Key, T, Hash, KeyEqual, Allocator> const& lhs,
+      unordered_flat_map<Key, T, Hash, KeyEqual, Allocator> const& rhs)
    {
      return !(lhs == rhs);
    }

-    template <class Key, class T, class Hash, class KeyEqual, class Allocator, class MixPolicy>
-    void swap(unordered_flat_map<Key, T, Hash, KeyEqual, Allocator, MixPolicy>& lhs,
-      unordered_flat_map<Key, T, Hash, KeyEqual, Allocator, MixPolicy>& rhs)
+    template <class Key, class T, class Hash, class KeyEqual, class Allocator>
+    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)))
    {
      lhs.swap(rhs);
    }

-    template <class Key, class T, class Hash, class KeyEqual, class Allocator, class MixPolicy,
+    template <class Key, class T, class Hash, class KeyEqual, class Allocator,
      class Pred>
-    typename unordered_flat_map<Key, T, Hash, KeyEqual, Allocator, MixPolicy>::size_type
+    typename unordered_flat_map<Key, T, Hash, KeyEqual, Allocator>::size_type
    erase_if(
-      unordered_flat_map<Key, T, Hash, KeyEqual, Allocator, MixPolicy>& map, Pred pred)
+      unordered_flat_map<Key, T, Hash, KeyEqual, Allocator>& map, Pred pred)
    {
      return erase_if(map.table_, pred);
    }
@@ -18,28 +18,24 @@

 namespace boost {
  namespace unordered {
-
-    namespace detail { namespace foa { struct xmx_mix; } }
-
    template <class Key, class T, class Hash = boost::hash<Key>,
      class KeyEqual = std::equal_to<Key>,
-      class Allocator = std::allocator<std::pair<const Key, T> >,
-      class MixPolicy = detail::foa::xmx_mix >
+      class Allocator = std::allocator<std::pair<const Key, T> > >
    class unordered_flat_map;

-    template <class Key, class T, class Hash, class KeyEqual, class Allocator, class MixPolicy>
+    template <class Key, class T, class Hash, class KeyEqual, class Allocator>
    bool operator==(
-      unordered_flat_map<Key, T, Hash, KeyEqual, Allocator, MixPolicy> const& lhs,
-      unordered_flat_map<Key, T, Hash, KeyEqual, Allocator, MixPolicy> const& rhs);
+      unordered_flat_map<Key, T, Hash, KeyEqual, Allocator> const& lhs,
+      unordered_flat_map<Key, T, Hash, KeyEqual, Allocator> const& rhs);

-    template <class Key, class T, class Hash, class KeyEqual, class Allocator, class MixPolicy>
+    template <class Key, class T, class Hash, class KeyEqual, class Allocator>
    bool operator!=(
-      unordered_flat_map<Key, T, Hash, KeyEqual, Allocator, MixPolicy> const& lhs,
-      unordered_flat_map<Key, T, Hash, KeyEqual, Allocator, MixPolicy> const& rhs);
+      unordered_flat_map<Key, T, Hash, KeyEqual, Allocator> const& lhs,
+      unordered_flat_map<Key, T, Hash, KeyEqual, Allocator> const& rhs);

-    template <class Key, class T, class Hash, class KeyEqual, class Allocator, class MixPolicy>
-    void swap(unordered_flat_map<Key, T, Hash, KeyEqual, Allocator, MixPolicy>& lhs,
-      unordered_flat_map<Key, T, Hash, KeyEqual, Allocator, MixPolicy>& rhs)
+    template <class Key, class T, class Hash, class KeyEqual, class Allocator>
+    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)));
  } // namespace unordered

@@ -313,14 +313,14 @@ namespace boost {
      /// Lookup
      ///

-      BOOST_FORCEINLINE size_type count(key_type const& key) const
+      size_type count(key_type const& key) const
      {
        auto pos = table_.find(key);
        return pos != table_.end() ? 1 : 0;
      }

      template <class K>
-      BOOST_FORCEINLINE typename std::enable_if<
+      typename std::enable_if<
        detail::are_transparent<K, hasher, key_equal>::value, size_type>::type
      count(K const& key) const
      {
@@ -356,13 +356,13 @@ namespace boost {
        return table_.find(key);
      }

-      BOOST_FORCEINLINE bool contains(key_type const& key) const
+      bool contains(key_type const& key) const
      {
        return this->find(key) != this->end();
      }

      template <class K>
-      BOOST_FORCEINLINE typename std::enable_if<
+      typename std::enable_if<
        boost::unordered::detail::are_transparent<K, hasher, key_equal>::value,
        bool>::type
      contains(K const& key) const
@@ -60,9 +60,6 @@ template <class T> struct assign_base : public test::exception_base
  test::random_values<T> x_values, y_values;
  T x, y;

-  int t1;
-  int t2;
-
  typedef typename T::hasher hasher;
  typedef typename T::key_equal key_equal;
  typedef typename T::allocator_type allocator_type;
@@ -70,10 +67,7 @@ template <class T> struct assign_base : public test::exception_base
  assign_base(int tag1, int tag2, float mlf1 = 1.0, float mlf2 = 1.0)
      : x_values(), y_values(),
        x(0, hasher(tag1), key_equal(tag1), allocator_type(tag1)),
-        y(0, hasher(tag2), key_equal(tag2), allocator_type(tag2)),
-        t1(tag1),
-        t2(tag2)
-
+        y(0, hasher(tag2), key_equal(tag2), allocator_type(tag2))
  {
    x.max_load_factor(mlf1);
    y.max_load_factor(mlf2);
@@ -95,22 +89,6 @@ template <class T> struct assign_base : public test::exception_base
  {
    test::check_equivalent_keys(x1);

-    if (x1.hash_function() == hasher(t1)) {
-      BOOST_TEST(x1.key_eq() == key_equal(t1));
-    }
-
-    if (x1.hash_function() == hasher(t2)) {
-      BOOST_TEST(x1.key_eq() == key_equal(t2));
-    }
-
-    if (x1.key_eq() == key_equal(t1)) {
-      BOOST_TEST(x1.hash_function() == hasher(t1));
-    }
-
-    if (x1.key_eq() == key_equal(t2)) {
-      BOOST_TEST(x1.hash_function() == hasher(t2));
-    }
-
    // If the container is empty at the point of the exception, the
    // internal structure is hidden, this exposes it, at the cost of
    // messing up the data.
@@ -20,7 +20,6 @@ template <class T> struct move_assign_base : public test::exception_base
 {
  test::random_values<T> x_values, y_values;
  T x, y;
-  int t1, t2;

  typedef typename T::hasher hasher;
  typedef typename T::key_equal key_equal;
@@ -29,9 +28,7 @@ template <class T> struct move_assign_base : public test::exception_base
  move_assign_base(int tag1, int tag2, float mlf1 = 1.0, float mlf2 = 1.0)
      : x_values(), y_values(),
        x(0, hasher(tag1), key_equal(tag1), allocator_type(tag1)),
-        y(0, hasher(tag2), key_equal(tag2), allocator_type(tag2)),
-        t1(tag1),
-        t2(tag2)
+        y(0, hasher(tag2), key_equal(tag2), allocator_type(tag2))
  {
    x.max_load_factor(mlf1);
    y.max_load_factor(mlf2);
@@ -55,22 +52,6 @@ template <class T> struct move_assign_base : public test::exception_base
  {
    test::check_equivalent_keys(x1);

-    if (x1.hash_function() == hasher(t1)) {
-      BOOST_TEST(x1.key_eq() == key_equal(t1));
-    }
-
-    if (x1.hash_function() == hasher(t2)) {
-      BOOST_TEST(x1.key_eq() == key_equal(t2));
-    }
-
-    if (x1.key_eq() == key_equal(t1)) {
-      BOOST_TEST(x1.hash_function() == hasher(t1));
-    }
-
-    if (x1.key_eq() == key_equal(t2)) {
-      BOOST_TEST(x1.hash_function() == hasher(t2));
-    }
-
    // If the container is empty at the point of the exception, the
    // internal structure is hidden, this exposes it, at the cost of
    // messing up the data.
@@ -4,40 +4,15 @@
 // 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)

-#define BOOST_ENABLE_ASSERT_HANDLER
-#include <boost/assert.hpp>
-
 #include "./containers.hpp"

+#if defined(BOOST_UNORDERED_FOA_TESTS)
+#define BOOST_UNORDERED_FOA_WEAK_GUARANTEE_SWAP_EXCEPTIONS_TESTS
+#endif
+
 #include "../helpers/invariants.hpp"
 #include "../helpers/random_values.hpp"
 #include "../helpers/tracker.hpp"
-#include "../objects/test.hpp"
-
-#include <sstream>
-
-namespace boost {
-  void assertion_failed(
-    char const* expr, char const* function, char const* file, long line)
-  {
-    std::stringstream ss;
-    ss << expr << "\nin " << function << " failed at : " << file << ", line "
-       << line;
-
-    throw std::runtime_error(ss.str());
-  }
-
-  void assertion_failed_msg(char const* expr, char const* msg,
-    char const* function, char const* file, long line)
-  {
-    std::stringstream ss;
-    ss << expr << "\nin " << function << " failed at : " << file << ", line "
-       << line << "\n"
-       << msg;
-
-    throw std::runtime_error(ss.str());
-  }
-} // namespace boost

 #if defined(BOOST_MSVC)
 #pragma warning(disable : 4512) // assignment operator could not be generated
@@ -64,10 +39,15 @@ template <class T> struct self_swap_base : public test::exception_base

  void check BOOST_PREVENT_MACRO_SUBSTITUTION(T const& x) const
  {
-    (void)x;
+    std::string scope(test::scope);

-    BOOST_ERROR("An exception leaked when it should not have. Allocator "
-                "equality assertion must precede all other ops");
+    // TODO: In C++11 exceptions are only allowed in the swap function.
+    BOOST_TEST(scope == "hash::hash(hash)" ||
+               scope == "hash::operator=(hash)" ||
+               scope == "equal_to::equal_to(equal_to)" ||
+               scope == "equal_to::operator=(equal_to)");
+
+    test::check_equivalent_keys(x);
  }
 };

@@ -160,133 +140,11 @@ template <class T> struct swap_test4 : swap_base<T>
  swap_test4() : swap_base<T>(10, 10, 1, 2) {}
 };

-template <class T> struct unequal_alloc_swap_base : public test::exception_base
-{
-  const test::random_values<T> x_values, y_values;
-  const T initial_x, initial_y;
-
-  typedef typename T::hasher hasher;
-  typedef typename T::key_equal key_equal;
-  typedef typename T::allocator_type allocator_type;
-
-  unequal_alloc_swap_base(unsigned int count1, unsigned int count2)
-      : x_values(count1, test::limited_range),
-        y_values(count2, test::limited_range),
-        initial_x(x_values.begin(), x_values.end(), 0, allocator_type(1337)),
-        initial_y(y_values.begin(), y_values.end(), 0, allocator_type(7331))
-  {
-  }
-
-  struct data_type
-  {
-    data_type(T const& x_, T const& y_) : x(x_), y(y_) {}
-
-    T x, y;
-  };
-
-  data_type init() const { return data_type(initial_x, initial_y); }
-
-  void run(data_type& d) const
-  {
-    bool assert_threw = false;
-
-    BOOST_TEST(d.x.get_allocator() != d.y.get_allocator());
-
-    try {
-      d.x.swap(d.y);
-    } catch (std::runtime_error&) {
-      assert_threw = true;
-    }
-
-    DISABLE_EXCEPTIONS;
-    BOOST_TEST(assert_threw);
-    test::check_container(d.x, this->x_values);
-    test::check_equivalent_keys(d.x);
-    test::check_container(d.y, this->y_values);
-    test::check_equivalent_keys(d.y);
-  }
-
-  void check BOOST_PREVENT_MACRO_SUBSTITUTION(data_type const& d) const
-  {
-    std::string scope(test::scope);
-
-    // TODO: In C++11 exceptions are only allowed in the swap function.
-    BOOST_TEST(scope == "hash::hash(hash)" ||
-               scope == "hash::operator=(hash)" ||
-               scope == "equal_to::equal_to(equal_to)" ||
-               scope == "equal_to::operator=(equal_to)");
-
-    test::check_equivalent_keys(d.x);
-    test::check_equivalent_keys(d.y);
-  }
-};
-
-template <class T> struct unequal_alloc_swap_test1 : unequal_alloc_swap_base<T>
-{
-  unequal_alloc_swap_test1() : unequal_alloc_swap_base<T>(0, 0) {}
-};
-
-template <class T> struct unequal_alloc_swap_test2 : unequal_alloc_swap_base<T>
-{
-  unequal_alloc_swap_test2() : unequal_alloc_swap_base<T>(0, 10) {}
-};
-
-template <class T> struct unequal_alloc_swap_test3 : unequal_alloc_swap_base<T>
-{
-  unequal_alloc_swap_test3() : unequal_alloc_swap_base<T>(10, 0) {}
-};
-
-template <class T> struct unequal_alloc_swap_test4 : unequal_alloc_swap_base<T>
-{
-  unequal_alloc_swap_test4() : unequal_alloc_swap_base<T>(10, 10) {}
-};
-
-#if defined(BOOST_UNORDERED_FOA_TESTS)
-
-using unordered_flat_set = boost::unordered_flat_set<int, boost::hash<int>,
-  std::equal_to<int>, test::allocator1<int> >;
-using unordered_flat_map = boost::unordered_flat_map<int, int, boost::hash<int>,
-  std::equal_to<int>, test::allocator1<std::pair<int const, int> > >;
-
-#define SWAP_CONTAINER_SEQ (unordered_flat_set)(unordered_flat_map)
-
-#else
-
-typedef boost::unordered_set<int, boost::hash<int>, std::equal_to<int>,
-  test::allocator1<int> >
-  unordered_set;
-typedef boost::unordered_map<int, int, boost::hash<int>, std::equal_to<int>,
-  test::allocator1<std::pair<int const, int> > >
-  unordered_map;
-typedef boost::unordered_multiset<int, boost::hash<int>, std::equal_to<int>,
-  test::allocator1<int> >
-  unordered_multiset;
-typedef boost::unordered_multimap<int, int, boost::hash<int>,
-  std::equal_to<int>, test::allocator1<std::pair<int const, int> > >
-  unordered_multimap;
-
-#define SWAP_CONTAINER_SEQ                                                     \
-  (unordered_set)(unordered_map)(unordered_multiset)(unordered_multimap)
-#endif
-
-// FOA containers deliberately choose to not offer the strong exception
-// guarantee so we can't reliably test what happens if swapping one of the data
-// members throws
-//
 // clang-format off
-#if !defined(BOOST_UNORDERED_FOA_TESTS)
 EXCEPTION_TESTS(
  (self_swap_test1)(self_swap_test2)
  (swap_test1)(swap_test2)(swap_test3)(swap_test4),
  CONTAINER_SEQ)
-#endif
-
-// want to prove that when assertions are defined as throwing operations that we
-// uphold invariants
-EXCEPTION_TESTS(
-  (unequal_alloc_swap_test1)(unequal_alloc_swap_test2)
-  (unequal_alloc_swap_test3)(unequal_alloc_swap_test4),
-  SWAP_CONTAINER_SEQ)
 // clang-format on

 RUN_TESTS()
@@ -54,10 +54,20 @@ namespace test {
      if (test::has_unique_keys<X>::value && count != 1)
        BOOST_ERROR("Non-unique key.");

+#if !defined(BOOST_UNORDERED_FOA_WEAK_GUARANTEE_SWAP_EXCEPTIONS_TESTS)
+      // we conditionally compile this check because our FOA implementation only
+      // exhibits the weak guarantee when swapping throws
+      //
+      // in this case, the hasher may be changed before the predicate and the
+      // arrays are swapped in which case, we can can find an element by
+      // iteration but unfortunately, it's in the wrong slot according to the
+      // new hash function so count(key) can wind up returning nothing when
+      // there really is something
      if (x1.count(key) != count) {
        BOOST_ERROR("Incorrect output of count.");
        std::cerr << x1.count(key) << "," << count << "\n";
      }
+#endif

 #ifndef BOOST_UNORDERED_FOA_TESTS
      // Check that the keys are in the correct bucket and are
@@ -227,21 +227,8 @@ namespace test {
        }
        return x1.tag_ != x2.tag_;
      }
-
-#if defined(BOOST_UNORDERED_FOA_TESTS)
-      friend void swap(hash&, hash&) noexcept;
-#endif
    };

-#if defined(BOOST_UNORDERED_FOA_TESTS)
-      void swap(hash& lhs, hash& rhs) noexcept
-      {
-        int tag = lhs.tag_;
-        lhs.tag_ = rhs.tag_;
-        rhs.tag_ = tag;
-      }
-#endif
-
    class less
    {
      int tag_;
@@ -377,20 +364,8 @@ namespace test {
      }

      friend less create_compare(equal_to x) { return less(x.tag_); }
-#if defined(BOOST_UNORDERED_FOA_TESTS)
-      friend void swap(equal_to&, equal_to&) noexcept;
-#endif
    };

-#if defined(BOOST_UNORDERED_FOA_TESTS)
-    void swap(equal_to& lhs, equal_to& rhs) noexcept
-    {
-      int tag = lhs.tag_;
-      lhs.tag_ = rhs.tag_;
-      rhs.tag_ = tag;
-    }
-#endif
-
    template <class T> class allocator
    {
    public:
@@ -206,11 +206,6 @@ namespace test {
      hash& operator=(hash const&) { return *this; }
      ~hash() {}

-#if defined(BOOST_UNORDERED_FOA_TESTS)
-      hash(hash&&) = default;
-      hash& operator=(hash&&) = default;
-#endif
-
      std::size_t operator()(T const&) const { return 0; }
 #if BOOST_UNORDERED_CHECK_ADDR_OPERATOR_NOT_USED
      ampersand_operator_used operator&() const
@@ -229,11 +224,6 @@ namespace test {
      equal_to& operator=(equal_to const&) { return *this; }
      ~equal_to() {}

-#if defined(BOOST_UNORDERED_FOA_TESTS)
-      equal_to(equal_to&&) = default;
-      equal_to& operator=(equal_to&&) = default;
-#endif
-
      bool operator()(T const&, T const&) const { return true; }
 #if BOOST_UNORDERED_CHECK_ADDR_OPERATOR_NOT_USED
      ampersand_operator_used operator&() const
@@ -230,18 +230,18 @@ namespace test {

    std::size_t operator()(int x) const
    {
-      unsigned result;
+      int result;
      switch (type_) {
      case 1:
-        result = static_cast<unsigned>(x);
+        result = x;
        break;
      case 2:
-        result = static_cast<unsigned>(x) * 7;
+        result = x * 7;
        break;
      default:
-        result = static_cast<unsigned>(x) * 256;
+        result = x * 256;
      }
-      return result;
+      return static_cast<std::size_t>(result);
    }

    friend bool operator==(hash const& x1, hash const& x2)
@@ -225,227 +225,11 @@ namespace copy_tests {
    }
  }

-  template <class T>
-  void copy_construct_tests_std_allocator1(
-    T*, test::random_generator const& generator)
-  {
-    typename T::hasher hf;
-    typename T::key_equal eq;
-    typename T::allocator_type al;
-
-    {
-      test::check_instances check_;
-
-      T x;
-      T y(x);
-      BOOST_TEST(y.empty());
-      BOOST_TEST(test::equivalent(y.hash_function(), hf));
-      BOOST_TEST(test::equivalent(y.key_eq(), eq));
-      BOOST_TEST(test::equivalent(y.get_allocator(), al));
-      BOOST_TEST(x.max_load_factor() == y.max_load_factor());
-      BOOST_TEST(test::detail::tracker.count_allocations == 0);
-      test::check_equivalent_keys(y);
-    }
-
-    {
-      test::check_instances check_;
-
-      T x(0);
-      T y(x);
-      BOOST_TEST(y.empty());
-      BOOST_TEST(test::equivalent(y.hash_function(), hf));
-      BOOST_TEST(test::equivalent(y.key_eq(), eq));
-      BOOST_TEST(test::equivalent(y.get_allocator(), al));
-      BOOST_TEST(x.max_load_factor() == y.max_load_factor());
-      BOOST_TEST(test::detail::tracker.count_allocations == 0);
-      test::check_equivalent_keys(y);
-    }
-
-    {
-      test::check_instances check_;
-
-      test::random_values<T> v(1000, generator);
-
-      T x(v.begin(), v.end());
-      T y(x);
-      test::unordered_equivalence_tester<T> equivalent(x);
-      BOOST_TEST(equivalent(y));
-      test::check_equivalent_keys(y);
-    }
-
-    {
-      test::check_instances check_;
-
-      // In this test I drop the original containers max load factor, so it
-      // is much lower than the load factor. The hash table is not allowed
-      // to rehash, but the destination container should probably allocate
-      // enough buckets to decrease the load factor appropriately.
-      test::random_values<T> v(1000, generator);
-      T x(v.begin(), v.end());
-      x.max_load_factor(x.load_factor() / 4);
-      T y(x);
-      test::unordered_equivalence_tester<T> equivalent(x);
-      BOOST_TEST(equivalent(y));
-      // This isn't guaranteed:
-      BOOST_TEST(y.load_factor() < y.max_load_factor());
-      test::check_equivalent_keys(y);
-    }
-  }
-
-  template <class T>
-  void copy_construct_tests_std_allocator2(
-    T*, test::random_generator const& generator)
-  {
-    typename T::hasher hf(1);
-    typename T::key_equal eq(1);
-    typename T::allocator_type al;
-
-    {
-      test::check_instances check_;
-
-      T x(0, hf, eq, al);
-      T y(x);
-      BOOST_TEST(y.empty());
-      BOOST_TEST(test::equivalent(y.hash_function(), hf));
-      BOOST_TEST(test::equivalent(y.key_eq(), eq));
-      BOOST_TEST(test::equivalent(y.get_allocator(), al));
-      BOOST_TEST(x.max_load_factor() == y.max_load_factor());
-      BOOST_TEST(test::detail::tracker.count_allocations == 0);
-      test::check_equivalent_keys(y);
-    }
-
-    {
-      test::check_instances check_;
-
-      T x(10000, hf, eq, al);
-      T y(x);
-      BOOST_TEST(y.empty());
-      BOOST_TEST(test::equivalent(y.hash_function(), hf));
-      BOOST_TEST(test::equivalent(y.key_eq(), eq));
-      BOOST_TEST(test::equivalent(y.get_allocator(), al));
-      BOOST_TEST(x.max_load_factor() == y.max_load_factor());
-      test::check_equivalent_keys(y);
-    }
-
-    {
-      test::check_instances check_;
-
-      T x(0, hf, eq, al);
-      T y(x, al);
-      BOOST_TEST(y.empty());
-      BOOST_TEST(test::equivalent(y.hash_function(), hf));
-      BOOST_TEST(test::equivalent(y.key_eq(), eq));
-      BOOST_TEST(test::equivalent(y.get_allocator(), al));
-      BOOST_TEST(x.max_load_factor() == y.max_load_factor());
-      BOOST_TEST(test::selected_count(y.get_allocator()) == 0);
-      BOOST_TEST(test::detail::tracker.count_allocations == 0);
-      test::check_equivalent_keys(y);
-    }
-
-    {
-      test::check_instances check_;
-
-      T x(1000, hf, eq, al);
-      T y(x, al);
-      BOOST_TEST(y.empty());
-      BOOST_TEST(test::equivalent(y.hash_function(), hf));
-      BOOST_TEST(test::equivalent(y.key_eq(), eq));
-      BOOST_TEST(test::equivalent(y.get_allocator(), al));
-      BOOST_TEST(x.max_load_factor() == y.max_load_factor());
-      BOOST_TEST(test::selected_count(y.get_allocator()) == 0);
-      test::check_equivalent_keys(y);
-    }
-
-    {
-      test::check_instances check_;
-
-      test::random_values<T> v;
-
-      T x(v.begin(), v.end(), 0, hf, eq, al);
-      T y(x);
-      test::unordered_equivalence_tester<T> equivalent(x);
-      BOOST_TEST(equivalent(y));
-      test::check_equivalent_keys(y);
-      BOOST_TEST(test::equivalent(y.get_allocator(), al));
-      BOOST_TEST(test::detail::tracker.count_allocations == 0);
-    }
-
-    {
-      test::check_instances check_;
-
-      test::random_values<T> v(1000, generator);
-
-      T x(v.begin(), v.end(), 0, hf, eq, al);
-      T y(x);
-      test::unordered_equivalence_tester<T> equivalent(x);
-      BOOST_TEST(equivalent(y));
-      test::check_equivalent_keys(y);
-      BOOST_TEST(test::equivalent(y.get_allocator(), al));
-    }
-
-    {
-      test::check_instances check_;
-
-      test::random_values<T> v;
-
-      T x(v.begin(), v.end(), 0, hf, eq, al);
-      T y(x, al);
-      test::unordered_equivalence_tester<T> equivalent(x);
-      BOOST_TEST(equivalent(y));
-      test::check_equivalent_keys(y);
-      BOOST_TEST(test::selected_count(y.get_allocator()) == 0);
-      BOOST_TEST(test::equivalent(y.get_allocator(), al));
-      BOOST_TEST(test::detail::tracker.count_allocations == 0);
-    }
-
-    {
-      test::check_instances check_;
-
-      test::random_values<T> v(500, generator);
-
-      T x(v.begin(), v.end(), 0, hf, eq, al);
-      T y(x, al);
-      test::unordered_equivalence_tester<T> equivalent(x);
-      BOOST_TEST(equivalent(y));
-      test::check_equivalent_keys(y);
-      BOOST_TEST(test::selected_count(y.get_allocator()) == 0);
-      BOOST_TEST(test::equivalent(y.get_allocator(), al));
-    }
-  }
-
  using test::default_generator;
  using test::generate_collisions;
  using test::limited_range;

 #ifdef BOOST_UNORDERED_FOA_TESTS
-  template <class T> struct allocator
-  {
-    using value_type = T;
-
-    allocator() = default;
-    allocator(allocator const&) = default;
-    allocator(allocator&&) = default;
-
-    template <class U> allocator(allocator<U> const&) {}
-
-    T* allocate(std::size_t n)
-    {
-      return static_cast<T*>(::operator new(sizeof(value_type) * n));
-    }
-
-    void deallocate(T* p, std::size_t) { ::operator delete(p); }
-
-    friend inline bool operator==(allocator const&, allocator const&)
-    {
-      return true;
-    }
-
-    friend inline bool operator!=(allocator const&, allocator const&)
-    {
-      return false;
-    }
-  };
-
  boost::unordered_flat_set<test::object, test::hash, test::equal_to,
    test::allocator1<test::object> >* test_set;
  boost::unordered_flat_map<test::object, test::object, test::hash,
@@ -465,50 +249,13 @@ namespace copy_tests {
    test::equal_to, test::cxx11_allocator<test::object, test::no_select_copy> >*
    test_map_no_select_copy;

-  boost::unordered_flat_set<int, test::hash, test::equal_to,
-    test::allocator1<int> >* test_set_trivially_copyable;
-  boost::unordered_flat_map<int, int, test::hash, test::equal_to,
-    test::allocator1<std::pair<int const, int> > >* test_map_trivially_copyable;
-
-  boost::unordered_flat_set<int, test::hash, test::equal_to,
-    std::allocator<int> >* test_set_trivially_copyable_std_allocator;
-  boost::unordered_flat_map<int, int, test::hash, test::equal_to,
-    std::allocator<std::pair<int const, int> > >*
-    test_map_trivially_copyable_std_allocator;
-
-  boost::unordered_flat_set<int, test::hash, test::equal_to, allocator<int> >*
-    test_set_trivially_copyable_no_construct;
-  boost::unordered_flat_map<int, int, test::hash, test::equal_to,
-    allocator<std::pair<int const, int> > >*
-    test_map_trivially_copyable_no_construct;
-
-  // clang-format off
  UNORDERED_TEST(copy_construct_tests1,
-    ((test_set)(test_map)(test_set_select_copy)(test_map_select_copy)
-     (test_set_no_select_copy)(test_map_no_select_copy)
-     (test_set_trivially_copyable)(test_map_trivially_copyable))
-    ((default_generator)(generate_collisions)(limited_range)))
+    ((test_set)(test_map)(test_set_select_copy)(test_map_select_copy)(test_set_no_select_copy)(test_map_no_select_copy))(
+      (default_generator)(generate_collisions)(limited_range)))

  UNORDERED_TEST(copy_construct_tests2,
-    ((test_set)(test_map)(test_set_select_copy)(test_map_select_copy)
-     (test_set_no_select_copy)(test_map_no_select_copy)
-     (test_set_trivially_copyable)(test_map_trivially_copyable))
-    ((default_generator)(generate_collisions)(limited_range)))
-
-  UNORDERED_TEST(copy_construct_tests_std_allocator1,
-    ((test_set_trivially_copyable_std_allocator)
-     (test_map_trivially_copyable_std_allocator)
-     (test_set_trivially_copyable_no_construct)
-     (test_map_trivially_copyable_no_construct))
-    ((default_generator)(generate_collisions)(limited_range)))
-
-  UNORDERED_TEST(copy_construct_tests_std_allocator2,
-    ((test_set_trivially_copyable_std_allocator)
-     (test_map_trivially_copyable_std_allocator)
-     (test_set_trivially_copyable_no_construct)
-     (test_map_trivially_copyable_no_construct))
-    ((default_generator)(generate_collisions)(limited_range)))
-  // clang-format on
+    ((test_set)(test_map)(test_set_select_copy)(test_map_select_copy)(test_set_no_select_copy)(test_map_no_select_copy))(
+      (default_generator)(generate_collisions)(limited_range)))
 #else
  boost::unordered_set<test::object, test::hash, test::equal_to,
    test::allocator1<test::object> >* test_set;
@@ -437,11 +437,13 @@ UNORDERED_AUTO_TEST (prelim_allocator_checks) {
 using test::default_generator;

 #ifdef BOOST_UNORDERED_FOA_TESTS
-boost::unordered_flat_set<int, noexcept_tests::hash_nothrow_swap,
-  noexcept_tests::equal_to_nothrow_swap, allocator1<int> >* throwing_set_alloc1;
+boost::unordered_flat_set<int, noexcept_tests::hash_nothrow_move_assign,
+  noexcept_tests::equal_to_nothrow_move_assign, allocator1<int> >*
+  throwing_set_alloc1;

-boost::unordered_flat_set<int, noexcept_tests::hash_nothrow_swap,
-  noexcept_tests::equal_to_nothrow_swap, allocator2<int> >* throwing_set_alloc2;
+boost::unordered_flat_set<int, noexcept_tests::hash_nothrow_move_assign,
+  noexcept_tests::equal_to_nothrow_move_assign, allocator2<int> >*
+  throwing_set_alloc2;

 UNORDERED_TEST(test_nothrow_move_assign_when_noexcept,
  ((throwing_set_alloc1)(throwing_set_alloc2))((default_generator)))
@@ -21,7 +21,8 @@ void macros_test()
    BOOST_ERROR("std::numeric_limits<size_t>::digits >= 64, but "
                "BOOST_UNORDERED_FCA_HAS_64B_SIZE_T is not defined");
 #endif
-  } else {
+  }
+  else {
 #if defined(BOOST_UNORDERED_FCA_HAS_64B_SIZE_T)
    BOOST_ERROR("std::numeric_limits<size_t>::digits < 64, but "
                "BOOST_UNORDERED_FCA_HAS_64B_SIZE_T is defined");
@@ -154,7 +155,7 @@ void get_remainder_test()

  for (std::size_t i = 0; i < 1000000u; ++i) {
    boost::uint64_t f = rng();
-    boost::uint32_t d = rng() & 0xffffffffu;
+    boost::uint32_t d = static_cast<uint32_t>(rng());

    boost::uint64_t r1 =
      boost::unordered::detail::prime_fmod_size<>::get_remainder(f, d);
@@ -179,14 +180,14 @@ void modulo_test()
  boost::detail::splitmix64 rng;

  for (std::size_t i = 0; i < 1000000u; ++i) {
-    std::size_t hash = static_cast<std::size_t>(-1) & rng();
+    std::size_t hash = static_cast<std::size_t>(rng());

    for (std::size_t j = 0; j < sizes_len; ++j) {
      std::size_t h = hash;

 #if defined(BOOST_UNORDERED_FCA_HAS_64B_SIZE_T)
      if (sizes[j] <= UINT_MAX) {
-        h = boost::uint32_t(h & 0xffffffffu) + boost::uint32_t(h >> 32);
+        h = boost::uint32_t(h) + boost::uint32_t(h >> 32);
      }
 #endif
      std::size_t p1 =
Author	SHA1	Message	Date
joaquintides	1e57c08686	fourth attempt	2022-11-28 17:58:15 +01:00
joaquintides	3a34b8dae9	micro-optimized previous	2022-11-28 12:13:04 +01:00
joaquintides	0a91421fb8	third attempt	2022-11-27 20:54:26 +01:00
joaquintides	602488abc1	reverted `c463cf13fd` (wrong branch)	2022-11-24 20:12:48 +01:00
joaquintides	c463cf13fd	added "Open Addressing Implementation" section	2022-11-24 20:00:04 +01:00
joaquintides	09171776f7	second attempt	2022-11-24 13:01:09 +01:00
joaquintides	cf2a0ef303	added first draft of new pow2_size_policy	2022-11-22 20:06:29 +01:00