P1144 Relocation primitives

cmake/FindJemalloc.cmake

@@ -16,10 +16,10 @@ find_path(
         ENV
         JEMALLOC_ROOT
         ${HPX_JEMALLOC_ROOT}
-        ${PC_JEMALLOC_MINIMAL_INCLUDEDIR}
-        ${PC_JEMALLOC_MINIMAL_INCLUDE_DIRS}
-        ${PC_JEMALLOC_INCLUDEDIR}
-        ${PC_JEMALLOC_INCLUDE_DIRS}
+        ${PC_Jemalloc_MINIMAL_INCLUDEDIR}
+        ${PC_Jemalloc_MINIMAL_INCLUDE_DIRS}
+        ${PC_Jemalloc_INCLUDEDIR}
+        ${PC_Jemalloc_INCLUDE_DIRS}
   PATH_SUFFIXES include
 )
 
@@ -32,10 +32,10 @@ if(MSVC)
           ENV
           JEMALLOC_ROOT
           ${HPX_JEMALLOC_ROOT}
-          ${PC_JEMALLOC_MINIMAL_INCLUDEDIR}
-          ${PC_JEMALLOC_MINIMAL_INCLUDE_DIRS}
-          ${PC_JEMALLOC_INCLUDEDIR}
-          ${PC_JEMALLOC_INCLUDE_DIRS}
+          ${PC_Jemalloc_MINIMAL_INCLUDEDIR}
+          ${PC_Jemalloc_MINIMAL_INCLUDE_DIRS}
+          ${PC_Jemalloc_INCLUDEDIR}
+          ${PC_Jemalloc_INCLUDE_DIRS}
     PATH_SUFFIXES include
   )
 endif()
@@ -58,10 +58,10 @@ find_library(
         ENV
         JEMALLOC_ROOT
         ${HPX_JEMALLOC_ROOT}
-        ${PC_JEMALLOC_MINIMAL_LIBDIR}
-        ${PC_JEMALLOC_MINIMAL_LIBRARY_DIRS}
-        ${PC_JEMALLOC_LIBDIR}
-        ${PC_JEMALLOC_LIBRARY_DIRS}
+        ${PC_Jemalloc_MINIMAL_LIBDIR}
+        ${PC_Jemalloc_MINIMAL_LIBRARY_DIRS}
+        ${PC_Jemalloc_LIBDIR}
+        ${PC_Jemalloc_LIBRARY_DIRS}
   PATH_SUFFIXES lib lib64
 )
 

libs/core/type_support/CMakeLists.txt

@@ -22,7 +22,9 @@ set(type_support_headers
     hpx/type_support/lazy_enable_if.hpp
     hpx/type_support/pack.hpp
     hpx/type_support/meta.hpp
+    hpx/type_support/relocate_at.hpp
     hpx/type_support/static.hpp
+    hpx/type_support/uninitialized_relocate.hpp
     hpx/type_support/unwrap_ref.hpp
     hpx/type_support/unused.hpp
     hpx/type_support/void_guard.hpp

libs/core/type_support/include/hpx/type_support/is_relocatable.hpp

@@ -11,10 +11,25 @@
 namespace hpx {
 
     template <typename T>
-    struct is_relocatable : std::is_move_constructible<T>
+    struct is_relocatable
+      : std::bool_constant<std::is_move_constructible_v<T> &&
+            std::is_object_v<T>>
+    {
+    };
+
+    // ToTp(FromTp&&) must be well-formed
+    template <typename ToTp, typename FromTp>
+    struct is_relocatable_from
+      : std::bool_constant<
+            std::is_constructible_v<std::remove_cv_t<ToTp>, FromTp> &&
+            std::is_same_v<std::remove_cv_t<ToTp>, std::remove_cv_t<FromTp>>>
     {
     };
 
     template <typename T>
     inline constexpr bool is_relocatable_v = is_relocatable<T>::value;
+
+    template <typename ToTp, typename FromTp>
+    inline constexpr bool is_relocatable_from_v =
+        is_relocatable_from<ToTp, FromTp>::value;
 }    // namespace hpx

libs/core/type_support/include/hpx/type_support/is_trivially_relocatable.hpp

@@ -42,6 +42,61 @@ namespace hpx {
     {
     };
 
+    // References are not trivially relocatable
+    template <typename T>
+    struct is_trivially_relocatable<T&> : std::false_type
+    {
+    };
+
+    // Temporary objects are not trivially relocatable
+    template <typename T>
+    struct is_trivially_relocatable<T&&> : std::false_type
+    {
+    };
+
+    // Constness, Volatility, Arrays are ignored
+    template <typename T>
+    struct is_trivially_relocatable<T const> : is_trivially_relocatable<T>
+    {
+    };
+
+    template <typename T>
+    struct is_trivially_relocatable<T volatile> : is_trivially_relocatable<T>
+    {
+    };
+
+    template <typename T>
+    struct is_trivially_relocatable<T const volatile>
+      : is_trivially_relocatable<T>
+    {
+    };
+
+    template <typename T>
+    struct is_trivially_relocatable<T[]> : is_trivially_relocatable<T>
+    {
+    };
+
+    template <typename T, int N>
+    struct is_trivially_relocatable<T[N]> : is_trivially_relocatable<T>
+    {
+    };
+
+    template <typename T, int N>
+    struct is_trivially_relocatable<T const[N]> : is_trivially_relocatable<T>
+    {
+    };
+
+    template <typename T, int N>
+    struct is_trivially_relocatable<T volatile[N]> : is_trivially_relocatable<T>
+    {
+    };
+
+    template <typename T, int N>
+    struct is_trivially_relocatable<T const volatile[N]>
+      : is_trivially_relocatable<T>
+    {
+    };
+
     template <typename T>
     inline constexpr bool is_trivially_relocatable_v =
         is_trivially_relocatable<T>::value;

libs/core/type_support/include/hpx/type_support/relocate_at.hpp

@@ -0,0 +1,146 @@
+//  Copyright (c) 2023 Isidoros Tsaousis-Seiras
+//
+//  SPDX-License-Identifier: BSL-1.0
+//  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)
+
+#pragma once
+
+#include <hpx/concepts/concepts.hpp>
+#include <hpx/type_support/construct_at.hpp>
+#include <hpx/type_support/is_relocatable.hpp>
+#include <hpx/type_support/is_trivially_relocatable.hpp>
+
+#include <cstring>
+#include <type_traits>
+
+#if defined(HPX_HAVE_P1144_STD_RELOCATE_AT)
+#include <memory>
+#endif
+
+namespace hpx::detail {
+#if __cplusplus < 202002L
+    // until c++20 std::destroy_at can be used only on non-array types
+    template <typename T,
+        HPX_CONCEPT_REQUIRES_(std::is_destructible_v<T> && !std::is_array_v<T>)>
+#else
+    // since c++20 std::destroy_at can be used on array types, destructing each element
+    template <typename T, HPX_CONCEPT_REQUIRES_(std::is_destructible_v<T>)>
+#endif
+    struct destroy_guard
+    {
+        T* t;
+        explicit destroy_guard(T* t)
+          : t(t)
+        {
+        }
+        ~destroy_guard()
+        {
+            std::destroy_at(t);
+        }
+    };
+}    // namespace hpx::detail
+
+#if defined(HPX_HAVE_P1144_STD_RELOCATE_AT)
+using std::relocate;
+using std::relocate_at;
+#else
+
+namespace hpx::experimental {
+
+    namespace detail {
+
+        /*
+        The condition to use memmove is:
+                hpx::is_trivially_relocatable_v<T> &&
+                !std::is_volatile_v<T>
+
+        The reason for the volatile check is that memmove is not allowed to
+        change the value of a volatile object.
+        */
+
+        template <typename T>
+        constexpr bool relocate_using_memmove =
+            hpx::is_trivially_relocatable_v<T> && !std::is_volatile_v<T>;
+
+        template <typename T,
+            std::enable_if_t<relocate_using_memmove<T>, int> = 0>
+        T* relocate_at_helper(T* src, T* dst) noexcept
+        {
+            void* dst_void = const_cast<void*>(static_cast<const void*>(dst));
+            void* src_void = const_cast<void*>(static_cast<const void*>(src));
+
+            std::memmove(dst_void, src_void, sizeof(T));
+
+            return std::launder(dst);
+        };
+
+        // this is move and destroy
+        template <typename T,
+            std::enable_if_t<!relocate_using_memmove<T>, int> = 0>
+        T* relocate_at_helper(T* src, T* dst) noexcept(
+            std::is_nothrow_move_constructible_v<T>)
+        {
+            hpx::detail::destroy_guard g(src);
+            return hpx::construct_at(dst, HPX_MOVE(*src));
+        };
+
+        template <typename T>
+        T relocate_helper(T* src) noexcept(
+            std::is_nothrow_move_constructible_v<T>)
+        {
+            hpx::detail::destroy_guard g(src);
+            return HPX_MOVE(*src);
+        }
+
+        /*
+        P1144 also proposes a version of relocate that does not call the
+        move constructor and instead memmoves the bytes of src to dest.
+
+        Giving an interface like:
+
+            T dest = relocate(std::addressof(src));
+
+        That results in a valid T object (dest) without calling any
+        constructor or destructor.
+
+        This is not possible to do with the current C++ standard.
+
+        One of the proposed ways to implement this uses a hypothetical
+        attribute "do_not_construct" and NRVO.
+
+        Implementation:
+
+        template <class T, std::enable_if_t<relocate_using_memmove<T>, int> = 0>
+        T relocate(T* source)
+        {
+            __attribute__((do_not_construct)) T t; // hypothetical attribute
+            std::memmove(std::addressof(t), source, sizeof(T));
+            return t;  // NRVO
+        }
+        */
+    }    // namespace detail
+
+    template <typename T>
+    T* relocate_at(T* src, T* dst) noexcept(
+        // noexcept if the memmove path is taken or if the move path is noexcept
+        noexcept(detail::relocate_at_helper(src, dst)))
+    {
+        static_assert(hpx::is_relocatable_v<T>,
+            "new (dst) T(std::move(*src)) must be well-formed");
+
+        return detail::relocate_at_helper(src, dst);
+    }
+
+    template <typename T>
+    T relocate(T* src) noexcept(noexcept(detail::relocate_helper(src)))
+    {
+        static_assert(
+            hpx::is_relocatable_v<T>, "T(std::move(*src)) must be well-formed");
+
+        return detail::relocate_helper(src);
+    }
+
+#endif    // !defined(HPX_HAVE_P1144_STD_RELOCATE_AT)
+
+}    // namespace hpx::experimental