[libc++][PMR] Implement pmr::memory_resource

[Mordante]

libcxx/include/CMakeLists.txt

403

There are no changes to the module map.

libcxx/include/__memory_resource/memory_resource.h

13

Bit has been added in C++20.

27

please use size_t as in the Standard.

34

Please add some comment or a link to the documentation of this non-standard attribute.

38

As a side not in C++20 I would have preferred std::has_single_bit instead.

38

Can you add a test that triggers this _LIBCPP_ASSERT?

57

libcxx/include/memory_resource

9

Can you use /* ... */ like the other synosis do. That makes it easier to copy paste code from the Standard.

26

Please add the comparison operators too.

libcxx/src/memory_resource.cpp

14

What is the reason to put the destructor in the dylib?

When keeping it in the dylib it needs _AVAILABLITY_MACROS, grep for _LIBCPP_AVAILABILITY_FORMAT for an example.

libcxx/test/std/mem/mem.res/memory_resource.pass.cpp

89

Can you use the comparision_tests.h and validate the noexcept status and whether the function returns a bool.

[huixie90]

libcxx/include/__memory_resource/memory_resource.h

32

Question : can we inline the =default it in the header? Or is there an abi requirement that the vtable must exist in the library?

33

Is memory_resource& operator=(const memory_resource&) = default; missing?

56

missing noexcept

61

noexcept

[jwakely]

libcxx/include/__memory_resource/memory_resource.h

57

Why bother to use std::addressof? There is no memory_resource::operator& and it's not a template, so ADL isn't going to find operator& in any user namespaces. Is that a policy? It seems like unnecessary obfuscation.

libcxx/src/memory_resource.cpp

14

What is the reason to put the destructor in the dylib?

It's the key function, so the vtable will be generated where this function is defined. If it's inline, the vtable gets generated in every TU that uses memory_resource. Maybe that's OK though.

[ldionne]

FWIW we are dropping this in favour of D89057. @philnik I think you should abandon to avoid confusion.

libcxx/docs/Status/Cxx20.rst

 
 .. csv-table::
    :file: Cxx20Papers.csv
    :header-rows: 1
    :widths: auto
 
 .. note::
 
-   .. [#note-P0600] P0600: The missing bits in P0600 are in |sect|\ [mem.res.class] and |sect|\ [mem.poly.allocator.class].
+   .. [#note-P0600] P0600: The missing bits in P0600 are in |sect|\ [mem.poly.allocator.class].
    .. [#note-P0645] P0645: The paper is implemented but still marked as an incomplete feature
       (the feature-test macro is not set and the libary is only available when built with ``-fexperimental-library``).
       Not yet implemented LWG-issues will cause API and ABI breakage.
    .. [#note-P0966] P0966: It was previously erroneously marked as complete in version 8.0. See `bug 45368 <https://llvm.org/PR45368>`__.
    .. [#note-P0619] P0619: Only sections D.8, D.9, D.10 and D.13 are implemented. Sections D.4, D.7, D.11, D.12, and D.14 remain undone.
    .. [#note-P0883.1] P0883: shared_ptr and floating-point changes weren't applied as they themselves aren't implemented yet.
    .. [#note-P0883.2] P0883: ``ATOMIC_FLAG_INIT`` was marked deprecated in version 14.0, but was undeprecated with the implementation of LWG3659 in version 15.0.
    .. [#note-P2231] P2231: Optional is complete. The changes to variant haven't been implemented yet.

libcxx/include/CMakeLists.txt

set(files
   __memory/raw_storage_iterator.h
   __memory/shared_ptr.h
   __memory/swap_allocator.h
   __memory/temporary_buffer.h
   __memory/uninitialized_algorithms.h
   __memory/unique_ptr.h
   __memory/uses_allocator.h
   __memory/voidify.h
+  __memory_resource/memory_resource.h
   __mutex_base
   __node_handle
   __numeric/accumulate.h
   __numeric/adjacent_difference.h
   __numeric/exclusive_scan.h
   __numeric/gcd_lcm.h
   __numeric/inclusive_scan.h
   __numeric/inner_product.h
set(files
   limits
   limits.h
   list
   locale
   locale.h
   map
   math.h
   memory
+  memory_resource
   mutex
   new
   numbers
   numeric
   optional
   ostream
   queue
   random

libcxx/include/__memory_resource/memory_resource.h

+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___MEMORY_RESOURCE_MEMORY_RESOURCE_H
+#define _LIBCPP___MEMORY_RESOURCE_MEMORY_RESOURCE_H
+
+#include <__config>
+#include <bit>
+#include <cstddef>
+#include <new>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+#if _LIBCPP_STD_VER >= 17
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+namespace pmr {
+class _LIBCPP_TYPE_VIS memory_resource {
+  static constexpr auto __max_align = alignof(max_align_t);
+
+public:
+  memory_resource()                       = default;
+  memory_resource(const memory_resource&) = default;
+  _LIBCPP_FUNC_VIS virtual ~memory_resource();
+
+  [[using __gnu__: __returns_nonnull__,
+    __alloc_size__(2),
+    __alloc_align__(3)]] [[nodiscard]] _LIBCPP_HIDE_FROM_ABI void*
+  allocate(size_t __bytes, size_t __alignment = __max_align) {
+    _LIBCPP_ASSERT(std::popcount(__alignment) == 1, "alignment has to be a power of two");
+    return ::operator new(__bytes, do_allocate(__bytes, __alignment));
+  }
+
+  [[__gnu__::__nonnull__]] _LIBCPP_HIDE_FROM_ABI void
+  deallocate(void* __ptr, size_t __bytes, size_t __alignment = __max_align) {
+    return do_deallocate(__ptr, __bytes, __alignment);
+  }
+
+  _LIBCPP_HIDE_FROM_ABI bool is_equal(const memory_resource& __other) const noexcept { return do_is_equal(__other); }
+
+private:
+  virtual void* do_allocate(size_t __bytes, size_t __alignment)               = 0;
+  virtual void do_deallocate(void* __ptr, size_t __bytes, size_t __alignment) = 0;
+
+  virtual bool do_is_equal(const memory_resource& __other) const noexcept = 0;
+};
+
+_LIBCPP_HIDE_FROM_ABI inline bool operator==(const memory_resource& __lhs, const memory_resource& __rhs) {
+  return &__lhs == &__rhs || __lhs.is_equal(__rhs);
+}
+
+#  if _LIBCPP_STD_VER == 17
+_LIBCPP_HIDE_FROM_ABI inline bool operator!=(const memory_resource& __lhs, const memory_resource& __rhs) {
+  return !(__lhs == __rhs);
+}
+#  endif
+
+} // namespace pmr
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP_STD_VER >= 17
+
+#endif // _LIBCPP___MEMORY_RESOURCE_MEMORY_RESOURCE_H

libcxx/include/memory_resource

+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+// namespace std::pmr {
+//   class memory_resource {
+//   public:
+//     memory_resource() = default;
+//     memory_resource(const memory_resource&) = default;
+//     virtual ~memory_resource();
+//
+//     memory_resource& operator=(const memory_resource&) = default;
+//     [[nodiscard]] void* allocate(size_t bytes, size_t alignment = max_align);
+//     void deallocate(void* p, size_t bytes, size_t alignment = max_align);
+//
+//   private:
+//     virtual void* do_allocate(size_t bytes, size_t alignment) = 0;
+//     virtual void do_deallocate(void* p, size_t bytes, size_t alignment) = 0;
+//
+//     virtual bool do_is_equal(const memory_resource& other) const noexcept = 0;
+//   };
+// }
+
+#ifndef _LIBCPP_MEMORY_RESOURCE
+#define _LIBCPP_MEMORY_RESOURCE
+
+#include <__config>
+#include <__memory_resource/memory_resource.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+#endif // _LIBCPP_MEMORY_RESOURCE

libcxx/src/CMakeLists.txt

set(LIBCXX_SOURCES
   include/ryu/d2s_full_table.h
   include/ryu/d2s_intrinsics.h
   include/ryu/digit_table.h
   include/ryu/f2s.h
   include/ryu/ryu.h
   include/to_chars_floating_point.h
   legacy_pointer_safety.cpp
   memory.cpp
+  memory_resource.cpp
   mutex.cpp
   mutex_destructor.cpp
   new.cpp
   optional.cpp
   random_shuffle.cpp
   ryu/d2fixed.cpp
   ryu/d2s.cpp
   ryu/f2s.cpp

libcxx/src/memory_resource.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
+//
+//===----------------------------------------------------------------------===//
+
+#include <memory_resource>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+namespace pmr {
+_LIBCPP_FUNC_VIS memory_resource::~memory_resource() = default;
+} // namespace pmr
+
+_LIBCPP_END_NAMESPACE_STD

libcxx/test/std/mem/mem.res/memory_resource.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
+//
+//===----------------------------------------------------------------------===//
+
+#include <cassert>
+#include <stdexcept>
+#include <memory_resource>
+#include <new>
+#include <type_traits>
+
+int a;
+
+bool allocate_has_been_called   = false;
+bool deallocate_has_been_called = false;
+bool is_equal_has_been_called   = false;
+
+class simple_resource : public std::pmr::memory_resource {
+protected:
+  void* do_allocate(size_t bytes, size_t alignment) override {
+    assert(bytes == 7);
+    assert(alignment == alignof(max_align_t));
+    assert(!allocate_has_been_called);
+    allocate_has_been_called = true;
+    return &a;
+  }
+
+  void do_deallocate(void* ptr, size_t bytes, size_t alignment) override {
+    assert(ptr == &a);
+    assert(bytes == 7);
+    assert(alignment == alignof(max_align_t));
+    assert(!deallocate_has_been_called);
+    deallocate_has_been_called = true;
+  }
+
+  bool do_is_equal(const std::pmr::memory_resource&) const noexcept override {
+    assert(!is_equal_has_been_called);
+    is_equal_has_been_called = true;
+    return false;
+  }
+};
+
+class equal_resource : public std::pmr::memory_resource {
+public:
+  bool ret_equal = false;
+
+protected:
+  void* do_allocate(size_t, size_t) override { assert(false); }
+
+  void do_deallocate(void*, size_t, size_t) override { assert(false); }
+
+  bool do_is_equal(const std::pmr::memory_resource&) const noexcept override { return ret_equal; }
+};
+
+class throwing_resource : public std::pmr::memory_resource {
+protected:
+  void* do_allocate(size_t, size_t) override { throw std::bad_alloc(); }
+
+  void do_deallocate(void*, size_t, size_t) override { assert(false); }
+
+  bool do_is_equal(const std::pmr::memory_resource&) const noexcept override { assert(false); }
+};
+
+static_assert(std::is_abstract_v<std::pmr::memory_resource>);
+
+int main(int, char**) {
+  {
+    simple_resource r{};
+
+    static_assert(std::is_same_v<decltype(r.allocate(0)), void*>);
+    static_assert(std::is_same_v<decltype(r.deallocate(nullptr, 0)), void>);
+    static_assert(std::is_same_v<decltype(r.is_equal(r)), bool>);
+
+    void* ret = r.allocate(7);
+    assert(ret == &a);
+    assert(allocate_has_been_called);
+    r.deallocate(ret, 7);
+    assert(deallocate_has_been_called);
+    assert(!r.is_equal(r));
+    assert(is_equal_has_been_called);
+  }
+
+  {
+    equal_resource r1{};
+    equal_resource r2{};
+    assert(r1 == r1);
+    assert(!r1.is_equal(r1));
+    assert(r1 != r2);
+    assert(!(r1 == r2));
+    r1.ret_equal = true;
+    r2.ret_equal = true;
+    assert(r1 == r1);
+    assert(r1.is_equal(r1));
+    assert(r1 == r2);
+    assert(!(r1 != r2));
+  }
+
+#ifndef TEST_HAS_NO_EXCEPTIONS
+  {
+    throwing_resource r{};
+    try {
+      (void)r.allocate(0);
+      assert(false);
+    } catch (const std::bad_alloc&) {
+    }
+  }
+#endif
+
+  return 0;
+}