Sync from upstream.

test/Jamfile.v2

@@ -122,6 +122,7 @@ local FCA_TESTS =
   transparent_tests
   unnecessary_copy_tests
   fancy_pointer_noleak
+  pmr_allocator_tests
 ;
 
 for local test in $(FCA_TESTS)
@@ -229,6 +230,7 @@ local FOA_TESTS =
   uses_allocator
   hash_is_avalanching_test
   fancy_pointer_noleak
+  pmr_allocator_tests
 ;
 
 for local test in $(FOA_TESTS)
@@ -338,6 +340,7 @@ local CFOA_TESTS =
   rw_spinlock_test8
   reentrancy_check_test
   explicit_alloc_ctor_tests
+  pmr_allocator_tests
 ;
 
 for local test in $(CFOA_TESTS)

test/cfoa/helpers.hpp

@@ -8,6 +8,8 @@
 #define BOOST_UNORDERED_TEST_CFOA_HELPERS_HPP
 
 #include "../helpers/generators.hpp"
+#include "../helpers/helpers.hpp"
+#include "../helpers/pmr.hpp"
 #include "../helpers/test.hpp"
 #include "common_helpers.hpp"
 

test/cfoa/pmr_allocator_tests.cpp

@@ -0,0 +1,8 @@
+// Copyright (C) 2024 Braden Ganetsky
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#define BOOST_UNORDERED_CFOA_TESTS
+#include <boost/unordered/concurrent_flat_map.hpp>
+#include <boost/unordered/concurrent_flat_set.hpp>
+#include "../unordered/pmr_allocator_tests.cpp"

test/helpers/helpers.hpp

@@ -51,6 +51,11 @@ namespace test {
       static_cast<typename std::iterator_traits<Iterator>::difference_type>(x));
     return it;
   }
+
+  template <typename Container>
+  using is_map =
+    std::integral_constant<bool, !std::is_same<typename Container::key_type,
+                                  typename Container::value_type>::value>;
 }
 
 #endif

test/helpers/pmr.hpp

@@ -0,0 +1,55 @@
+
+// Copyright 2024 Braden Ganetsky.
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or move at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_UNORDERED_TEST_PMR_HEADER
+#define BOOST_UNORDERED_TEST_PMR_HEADER
+
+#include <boost/config.hpp>
+
+#ifndef BOOST_NO_CXX17_HDR_MEMORY_RESOURCE
+
+#include <memory_resource>
+
+namespace test {
+  class counted_new_delete_resource : public std::pmr::memory_resource
+  {
+  public:
+    using std::pmr::memory_resource::memory_resource;
+    ~counted_new_delete_resource() override {}
+
+    std::size_t count() const { return _count; }
+
+  private:
+    void* do_allocate(std::size_t bytes, std::size_t alignment) override
+    {
+      _count += bytes;
+      return ::operator new(bytes, std::align_val_t(alignment));
+    }
+
+    void do_deallocate(
+      void* p, std::size_t bytes, std::size_t alignment) override
+    {
+      _count -= bytes;
+#if __cpp_sized_deallocation
+      ::operator delete(p, bytes, std::align_val_t(alignment));
+#else
+      ::operator delete(p, std::align_val_t(alignment));
+#endif
+    }
+
+    bool do_is_equal(
+      const std::pmr::memory_resource& other) const noexcept override
+    {
+      return this == &other;
+    }
+
+  private:
+    std::size_t _count = 0;
+  };
+} // namespace test
+
+#endif // !defined(BOOST_NO_CXX17_HDR_MEMORY_RESOURCE)
+
+#endif // !defined(BOOST_UNORDERED_TEST_PMR_HEADER)

test/unordered/pmr_allocator_tests.cpp

@@ -0,0 +1,253 @@
+//
+// Copyright 2024 Braden Ganetsky.
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#include "../helpers/helpers.hpp"
+#include "../helpers/pmr.hpp"
+#include "../helpers/test.hpp"
+#include "../helpers/unordered.hpp"
+#include <boost/config/pragma_message.hpp>
+#include <string>
+
+#ifdef BOOST_NO_CXX17_HDR_MEMORY_RESOURCE
+
+BOOST_PRAGMA_MESSAGE(
+  "Test skipped because C++17 header <memory_resource> is not available.")
+
+#elif defined(__MAC_OS_X_VERSION_MIN_REQUIRED) &&                              \
+  __MAC_OS_X_VERSION_MIN_REQUIRED < 140000
+
+BOOST_PRAGMA_MESSAGE(
+  "Test skipped because __MAC_OS_X_VERSION_MIN_REQUIRED < 140000");
+
+#else
+
+namespace pmr_allocator_tests {
+
+  using pmr_string = std::basic_string<char, std::char_traits<char>,
+    std::pmr::polymorphic_allocator<char> >;
+
+#if defined(BOOST_UNORDERED_CFOA_TESTS)
+  static boost::unordered::pmr::concurrent_flat_map<std::string, std::string>*
+    test_string_flat_map;
+  static boost::unordered::pmr::concurrent_flat_map<pmr_string, pmr_string>*
+    test_pmr_string_flat_map;
+  static boost::unordered::pmr::concurrent_flat_set<std::string>*
+    test_string_flat_set;
+  static boost::unordered::pmr::concurrent_flat_set<pmr_string>*
+    test_pmr_string_flat_set;
+#define PMR_ALLOCATOR_TESTS_ARGS                                               \
+  ((test_string_flat_map)(test_pmr_string_flat_map)(test_string_flat_set)(test_pmr_string_flat_set))
+#elif defined(BOOST_UNORDERED_FOA_TESTS)
+  static boost::unordered::pmr::unordered_flat_map<std::string, std::string>*
+    test_string_flat_map;
+  static boost::unordered::pmr::unordered_flat_map<pmr_string, pmr_string>*
+    test_pmr_string_flat_map;
+  static boost::unordered::pmr::unordered_node_map<std::string, std::string>*
+    test_string_node_map;
+  static boost::unordered::pmr::unordered_node_map<pmr_string, pmr_string>*
+    test_pmr_string_node_map;
+  static boost::unordered::pmr::unordered_flat_set<std::string>*
+    test_string_flat_set;
+  static boost::unordered::pmr::unordered_flat_set<pmr_string>*
+    test_pmr_string_flat_set;
+  static boost::unordered::pmr::unordered_node_set<std::string>*
+    test_string_node_set;
+  static boost::unordered::pmr::unordered_node_set<pmr_string>*
+    test_pmr_string_node_set;
+#define PMR_ALLOCATOR_TESTS_ARGS                                               \
+  ((test_string_flat_map)(test_pmr_string_flat_map)(test_string_node_map)(test_pmr_string_node_map)(test_string_flat_set)(test_pmr_string_flat_set)(test_string_node_set)(test_pmr_string_node_set))
+#else
+  static boost::unordered::pmr::unordered_map<std::string, std::string>*
+    test_string_map;
+  static boost::unordered::pmr::unordered_map<pmr_string, pmr_string>*
+    test_pmr_string_map;
+  static boost::unordered::pmr::unordered_multimap<std::string, std::string>*
+    test_string_multimap;
+  static boost::unordered::pmr::unordered_multimap<pmr_string, pmr_string>*
+    test_pmr_string_multimap;
+  static boost::unordered::pmr::unordered_set<std::string>* test_string_set;
+  static boost::unordered::pmr::unordered_set<pmr_string>* test_pmr_string_set;
+  static boost::unordered::pmr::unordered_multiset<std::string>*
+    test_string_multiset;
+  static boost::unordered::pmr::unordered_multiset<pmr_string>*
+    test_pmr_string_multiset;
+#define PMR_ALLOCATOR_TESTS_ARGS                                               \
+  ((test_string_map)(test_pmr_string_map)(test_string_multimap)(test_pmr_string_multimap)(test_string_set)(test_pmr_string_set)(test_string_multiset)(test_pmr_string_multiset))
+#endif
+
+  template <class X>
+  typename std::enable_if<!test::is_map<X>::value, std::size_t>::type
+  emplace_strings(X& x)
+  {
+    std::string_view sv =
+      "this is a string that's longer than the SBO threshold";
+    x.emplace(sv);
+    // Return how many chars were allocated using a pmr allocator
+    return std::is_same<typename X::key_type, pmr_string>::value ? sv.size() + 1
+                                                                 : 0;
+  }
+
+  template <class X>
+  typename std::enable_if<test::is_map<X>::value, std::size_t>::type
+  emplace_strings(X& x)
+  {
+    std::string_view key =
+      "this is a string that's longer than the SBO threshold";
+    std::string_view value =
+      "this is another long string that's longer than the SBO threshold";
+    x.emplace(key, value);
+    // Return how many chars were allocated using a pmr allocator
+    return std::is_same<typename X::key_type, pmr_string>::value
+             ? key.size() + value.size() + 2
+             : 0;
+  }
+
+  void validate_resource(
+    pmr_string const& str, test::counted_new_delete_resource const& resource)
+  {
+    BOOST_TEST_EQ(str.get_allocator().resource(), &resource);
+  }
+
+  void validate_resource(
+    std::string const&, test::counted_new_delete_resource const&)
+  {
+    // Pass through
+  }
+
+  template <class X>
+  typename std::enable_if<!test::is_map<X>::value>::type validate_resource(
+    X& x, test::counted_new_delete_resource const& resource)
+  {
+#if defined(BOOST_UNORDERED_CFOA_TESTS)
+    x.cvisit_all(
+      [&resource](auto& element) { validate_resource(element, resource); });
+#else
+    for (auto& element : x) {
+      validate_resource(element, resource);
+    }
+#endif
+  }
+
+  template <class X>
+  typename std::enable_if<test::is_map<X>::value>::type validate_resource(
+    X& x, test::counted_new_delete_resource const& resource)
+  {
+#if defined(BOOST_UNORDERED_CFOA_TESTS)
+    x.cvisit_all([&resource](auto& element) {
+      validate_resource(element.first, resource);
+      validate_resource(element.second, resource);
+    });
+#else
+    for (auto& element : x) {
+      validate_resource(element.first, resource);
+      validate_resource(element.second, resource);
+    }
+#endif
+  }
+
+  template <class X> static void pmr_emplace_erase(X*)
+  {
+    using container = X;
+    using allocator_type = typename container::allocator_type;
+
+    test::counted_new_delete_resource resource;
+
+    {
+      allocator_type alloc(&resource);
+      container x(alloc);
+
+      std::size_t num_chars = emplace_strings(x);
+      BOOST_TEST_EQ(x.size(), 1);
+      std::size_t count_after_emplace = resource.count();
+      BOOST_TEST_GT(count_after_emplace,
+        num_chars + sizeof(typename container::value_type));
+
+      validate_resource(x, resource);
+
+      x.clear();
+      BOOST_TEST_LE(resource.count(), count_after_emplace);
+    }
+
+    BOOST_TEST_EQ(resource.count(), 0);
+  }
+
+  // clang-format off
+
+  UNORDERED_TEST(
+    pmr_emplace_erase,
+    PMR_ALLOCATOR_TESTS_ARGS
+  )
+
+  // clang-format on
+
+  enum operation
+  {
+    copy_op,
+    move_op,
+    swap_op,
+  };
+
+  template <class X> void do_operation(X& x1, X& x2, operation op)
+  {
+    switch (op) {
+    case copy_op:
+      x2 = x1;
+      return;
+    case move_op:
+      x2 = std::move(x1);
+      return;
+    case swap_op:
+      x1.swap(x1); // Swapping with non-equal non-pocs allocators is UB
+      return;
+    default:
+      BOOST_TEST(false);
+    }
+  }
+
+  template <class X> static void pmr_no_propagate_on_operation(X*, operation op)
+  {
+    using container = X;
+    using allocator_type = typename container::allocator_type;
+    BOOST_STATIC_ASSERT(
+      !std::allocator_traits<
+        allocator_type>::propagate_on_container_copy_assignment::value);
+    BOOST_STATIC_ASSERT(
+      !std::allocator_traits<
+        allocator_type>::propagate_on_container_move_assignment::value);
+    BOOST_STATIC_ASSERT(!std::allocator_traits<
+                        allocator_type>::propagate_on_container_swap::value);
+
+    test::counted_new_delete_resource resource1;
+    test::counted_new_delete_resource resource2;
+
+    allocator_type alloc1(&resource1);
+    allocator_type alloc2(&resource2);
+
+    container x1(alloc1);
+    container x2(alloc2);
+    bool allocators_not_equal = x1.get_allocator() != x2.get_allocator();
+    BOOST_TEST(allocators_not_equal);
+
+    emplace_strings(x1);
+    do_operation(x1, x2, op);
+    allocators_not_equal = x1.get_allocator() != x2.get_allocator();
+    BOOST_TEST(allocators_not_equal);
+  }
+
+  // clang-format off
+
+  UNORDERED_TEST(
+    pmr_no_propagate_on_operation,
+    PMR_ALLOCATOR_TESTS_ARGS
+    ((copy_op)(move_op)(swap_op))
+  )
+
+  // clang-format on
+
+} // namespace pmr_allocator_tests
+
+#endif
+
+RUN_TESTS()