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) {
+        size_t __sz = sizeof(_Tp);
+
+        if (SIZE_MAX / __sz < __n)
+            _VSTD::__throw_length_error("polymorphic_allocator");
+        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(static_cast<void*>(__p), __n);
+    }
+
+    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/libcxx/memory/poly_alloc.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>
+
+// template <class T = std::byte> class polymorphic_allocator
+
+// void* allocate_bytes(size_t nbytes, size_t alignment = alignof(max_align_t));
+
+#include <memory_resource>
+#include <cassert>
+#include "test_macros.h"
+
+#define SIZE 8
+
+using alloc_t = std::pmr::polymorphic_allocator<>;
+
+template<class T>
+void fill_obj(T* p, T v, std::size_t size = SIZE)
+{
+    for (unsigned i = 0; i < size; ++i)
+        p[i] = v;
+}
+
+template<class T>
+void cmp_obj(T* a, T* b, std::size_t size = SIZE)
+{
+    for (unsigned i = 0; i < size; ++i)
+        assert(a[i] == b[i]);
+}
+
+template<class T>
+void test_polymorphic_alloc (T fill_val)
+{
+    alloc_t alloc = { };
+
+    T* a = static_cast<T*>(alloc.allocate_bytes(sizeof(T) * SIZE));
+    T* b = alloc.allocate_object<T>(SIZE);
+
+    fill_obj(a, fill_val);
+    fill_obj(b, fill_val);
+
+    cmp_obj(a, b);
+
+    ASSERT_SAME_TYPE(decltype(a), decltype(b));
+}
+
+struct Foo
+{ };
+
+struct Bar
+{ int a; double b; bool c; };
+
+bool destructor_called = false;
+class Baz
+{
+    Baz(int a, double b, bool c) {
+        assert(a == 1);
+        assert(b == 2.0);
+        assert(c == false);
+    }
+
+    ~Baz() {
+        destructor_called = true;
+    }
+}
+
+int main(int, char**)
+{
+    test_polymorphic_alloc<int>(1);
+    test_polymorphic_alloc<Foo>(Foo { });
+    test_polymorphic_alloc<Bar>(Bar { .a=3, .b=2.0 .c=true });
+
+    alloc_t alloc = { };
+    Baz* baz = alloc.new_object<Baz>(1, 2.0, false);
+    alloc.delete_object(baz);
+    assert(destructor_called == true);
+
+    return 0;
+}