Add polymorphic_allocator methods (P0339r5)

[zoecarver]

Summary

Add methods to polymorphic_allocator as specified in P0339r5.

[zoecarver]

Update www 2a status.

[zoecarver]

• update tests
• fix implementation issue

[zoecarver]

I am closing this patch until std::pmr is implemented.

include/experimental/memory_resource

 memory_resource * get_default_resource() _NOEXCEPT;
 
 _LIBCPP_FUNC_VIS
 memory_resource * set_default_resource(memory_resource * __new_res) _NOEXCEPT;
 
 // 8.6, memory.polymorphic.allocator.class
 
 // 8.6.1, memory.polymorphic.allocator.overview
+
+#if _LIBCPP_STD_VER > 17
+template <class _ValueType = byte> // std::byte is not available until C++17
+#else
 template <class _ValueType>
+#endif // _LIBCPP_STD_VER > 17
 class _LIBCPP_TEMPLATE_VIS polymorphic_allocator
 {
 public:
     typedef _ValueType value_type;
 
     // 8.6.2, memory.polymorphic.allocator.ctor
     _LIBCPP_INLINE_VISIBILITY
     polymorphic_allocator() _NOEXCEPT
void construct(pair<_T1, _T2> * __p, pair<_U1, _U2> && __pr){
             , _VSTD::forward_as_tuple(_VSTD::forward<_U2>(__pr.second)));
     }
 
     template <class _Tp>
     _LIBCPP_INLINE_VISIBILITY
     void destroy(_Tp * __p) _NOEXCEPT
         { __p->~_Tp(); }
 
+#if _LIBCPP_STD_VER > 17
+    _LIBCPP_INLINE_VISIBILITY
+    void* allocate_bytes(size_t __n,
+                         size_t __alignment = alignof(max_align_t)) {
+        return __res_->allocate(__n, __alignment);
+    }
+
+    _LIBCPP_INLINE_VISIBILITY
+    void deallocate_bytes(void* __p, size_t __n,
+                          size_t __alignment = alignof(max_align_t)) {
+        __res_->deallocate(__p, __n, __alignment);
+    }
+
+    template<class _Tp>
+    _LIBCPP_INLINE_VISIBILITY
+    _Tp* allocate_object(size_t __n = 1) {
+        const size_t __sz = sizeof(_Tp);
+
+        if (SIZE_MAX / __sz < __n)
+            _VSTD::__throw_length_error("Specified amount of storage exceeds SIZE_MAX");
+        else
+            return static_cast<_Tp*>(allocate_bytes(__n * __sz, alignof(_Tp)));
+    }
+
+    template<class _Tp>
+    _LIBCPP_INLINE_VISIBILITY
+    void deallocate_object(_Tp* __p, size_t __n = 1) {
+        deallocate_bytes(__p, __n * sizeof(_Tp), alignof(_Tp));
+    }
+
+    template<class _Tp, class... _Args>
+    _LIBCPP_INLINE_VISIBILITY
+    _Tp* new_object(_Args&&... __args) {
+        _Tp* __p = allocate_object<_Tp>();
+        try {
+            construct(__p, _VSTD::forward<_Args>(__args)...);
+        } catch (...) {
+            deallocate_object(__p);
+            throw;
+        }
+
+        return __p;
+    }
+
+    template<class _Tp>
+    _LIBCPP_INLINE_VISIBILITY
+    void delete_object(_Tp* __p) {
+        destroy(__p);
+        deallocate_object(__p);
+    }
+#endif // _LIBCPP_STD_VER > 17
+
     _LIBCPP_INLINE_VISIBILITY
     polymorphic_allocator
     select_on_container_copy_construction() const _NOEXCEPT
         { return polymorphic_allocator(); }
 
     _LIBCPP_INLINE_VISIBILITY
     memory_resource * resource() const _NOEXCEPT
         { return __res_; }

test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/object_allocation.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+
+// <memory_resource>
+
+//  void* allocate_bytes(size_t nbytes, size_t alignment = alignof(max_align_t));
+//  void deallocate_bytes(void* p, size_t nbytes,
+//                        size_t alignment = alignof(max_align_t));
+//  template <class T>
+//      T* allocate_object(size_t n = 1);
+//  template <class T>
+//      void deallocate_object(T* p, size_t n = 1);
+//  template <class T, class... CtorArgs>
+//      T* new_object(CtorArgs&&... ctor_args);
+//  template <class T>
+//      void delete_object(T* p);
+
+#include <experimental/memory_resource>
+#include <cassert>
+
+#include "test_macros.h"
+#include "test_memory_resource.hpp"
+
+template<class T = std::false_type>
+void test_alloc_bytes(std::size_t size)
+{
+    using allocator_type = typename std::conditional<std::is_same<T, std::byte>::value,
+                                                     std::experimental::pmr::polymorphic_allocator<>,
+                                                     std::experimental::pmr::polymorphic_allocator<T>>::type;
+
+    TestResource R;
+    allocator_type alloc(&R);
+
+    void* ptr = alloc.allocate_bytes(size, alignof(T));
+    assert(R.checkAlloc(ptr, size, alignof(T)));
+
+    alloc.deallocate_bytes(ptr, size, alignof(T));
+    assert(R.checkDealloc(ptr, size, alignof(T)));
+}
+
+template<class T>
+void test_alloc_obj(std::size_t size)
+{
+    using allocator_type = typename std::conditional<std::is_same<T, std::byte>::value,
+                                                     std::experimental::pmr::polymorphic_allocator<>,
+                                                     std::experimental::pmr::polymorphic_allocator<T>>::type;
+
+    TestResource R;
+    allocator_type alloc(&R);
+
+    auto* ptr = alloc. template allocate_object<T>(size);
+    ASSERT_SAME_TYPE(decltype(ptr), T*);
+    assert(R.checkAlloc(ptr, size * sizeof(T), alignof(T)));
+
+    alloc.deallocate_object(ptr, size);
+    assert(R.checkDealloc(ptr, size * sizeof(T), alignof(T)));
+
+    try {
+        alloc. template allocate_object<T>(SIZE_MAX * sizeof(T) + 1);
+        assert(false);
+    } catch (...) { }
+}
+
+template<class T, class... Args>
+void test_new_obj(Args&&... args)
+{
+    using allocator_type = typename std::conditional<std::is_same<T, std::byte>::value,
+                                                     std::experimental::pmr::polymorphic_allocator<>,
+                                                     std::experimental::pmr::polymorphic_allocator<T>>::type;
+
+    TestResource R;
+    allocator_type alloc(&R);
+
+    auto* ptr = alloc. template new_object<T>(std::forward<Args>(args)...);
+    ASSERT_SAME_TYPE(decltype(ptr), T*);
+    assert(R.checkAlloc(ptr, sizeof(T), alignof(T)));
+
+    alloc.delete_object(ptr);
+    assert(R.checkDealloc(ptr, sizeof(T), alignof(T)));
+}
+
+template<class T>
+void test()
+{
+    test_alloc_bytes<T>(1);
+    test_alloc_bytes<T>(8);
+    test_alloc_obj<T>(1);
+    test_alloc_obj<T>(8);
+    test_new_obj<T>();
+}
+
+struct Foo
+{
+    int a, b;
+
+    Foo() : a(0), b(0) { }
+    Foo(int a, int b) : a(a), b(b) { }
+
+    static void test()
+    {
+        TestResource R;
+        std::experimental::pmr::polymorphic_allocator<std::byte> alloc(&R);
+        auto* ptr = alloc. template new_object<Foo>(42, 101);
+        assert(ptr->a == 42 && ptr->b == 101);
+        alloc.delete_object(ptr);
+    }
+};
+
+int main(int, char**)
+{
+    test<int>();
+    test<char>();
+    test<Foo>();
+    test<std::byte>();
+
+    Foo::test();
+
+    return 0;
+}

www/cxx2a_status.html

-->
   <tr><td><a href="https://wg21.link/P1209R0">P1209R0</a></td><td>LWG</td><td>Adopt Consistent Container Erasure from Library Fundamentals 2 for C++20</td><td>San Diego</td><td>Complete</td><td>8.0</td></tr>
   <tr><td><a href="https://wg21.link/P1210R0">P1210R0</a></td><td>LWG</td><td>Completing the Rebase of Library Fundamentals, Version 3, Working Draft</td><td>San Diego</td><td><i> </i></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P1236R1">P1236R1</a></td><td>CWG</td><td>Alternative Wording for P0907R4 Signed Integers are Two's Complement</td><td>San Diego</td><td><i> </i></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P1248R1">P1248R1</a></td><td>LWG</td><td>Remove CommonReference requirement from StrictWeakOrdering (a.k.a Fixing Relations)</td><td>San Diego</td><td><i> </i></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P1285R0">P1285R0</a></td><td>LWG</td><td>Improving Completeness Requirements for Type Traits</td><td>San Diego</td><td><i> </i></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P1353R0">P1353R0</a></td><td>CWG</td><td>Missing feature test macros</td><td>San Diego</td><td><i> </i></td><td></td></tr>
 
    <tr><td></td><td></td><td></td><td></td><td></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P0339R6">P0339R6</a></td><td>LWG</td><td>polymorphic_allocator<> as a vocabulary type</td><td>Kona</td><td></td><td></td></tr>
+  <tr><td><a href="https://wg21.link/P0339R6">P0339R6</a></td><td>LWG</td><td>polymorphic_allocator<> as a vocabulary type</td><td>Kona</td><td>Complete</td><td></td></tr>
   <tr><td><a href="https://wg21.link/P0340R3">P0340R3</a></td><td>LWG</td><td>Making std::underlying_type SFINAE-friendly</td><td>Kona</td><td></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P0738R2">P0738R2</a></td><td>LWG</td><td>I Stream, You Stream, We All Stream for istream_iterator</td><td>Kona</td><td></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P0811R3">P0811R3</a></td><td>LWG</td><td>Well-behaved interpolation for numbers and pointers</td><td>Kona</td><td>Complete</td><td>9.0</td></tr>
   <tr><td><a href="https://wg21.link/P0920R2">P0920R2</a></td><td>LWG</td><td>Precalculated hash values in lookup</td><td>Kona</td><td></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P1001R2">P1001R2</a></td><td>LWG</td><td>Target Vectorization Policies from Parallelism V2 TS to C++20</td><td>Kona</td><td></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P1024R3">P1024R3</a></td><td>LWG</td><td>Usability Enhancements for std::span</td><td>Kona</td><td>Complete</td><td>9.0</td></tr>
   <tr><td><a href="https://wg21.link/P1164R1">P1164R1</a></td><td>LWG</td><td>Make create_directory() Intuitive</td><td>Kona</td><td></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P1227R2">P1227R2</a></td><td>LWG</td><td>Signed ssize() functions, unsigned size() functions </td><td>Kona</td><td>Complete</td><td>9.0</td></tr>