[window] Consistency for window allocate functions

Author: rodriados

src/mpiwcpp17/flag.hpp

@@ -12,7 +12,7 @@ MPIWCPP17_BEGIN_NAMESPACE
 
 namespace flag
 {
-    MPIWCPP17_INLINE namespace payload
+    inline namespace payload
     {
         /**
          * Guarantees that the quantity of message elements is uniform across all
@@ -30,7 +30,7 @@ namespace flag
         typedef struct{} varying_t;
     }
 
-    MPIWCPP17_INLINE namespace functor
+    inline namespace functor
     {
         /**
          * Indicates that a functor is commutative, allowing MPI to perform optimizations
@@ -39,23 +39,6 @@ namespace flag
          */
         typedef struct{} commutative_t;
     }
-
-    MPIWCPP17_INLINE namespace window
-    {
-        /**
-         * Indicates that the allocated memory for RMA operations is local to each
-         * process and cannot be accessed directly.
-         * @since 2.1
-         */
-        typedef struct{} local_t;
-
-        /**
-         * Indicates that the allocated memory for RMA operations is shared between
-         * processes and can be accessed directly by processes in the same communicator.
-         * @since 2.1
-         */
-        typedef struct{} shared_t;
-    }
 }
 
 MPIWCPP17_END_NAMESPACE

src/mpiwcpp17/memory.hpp

@@ -10,66 +10,41 @@
 
 #include <cstdint>
 #include <utility>
-#include <memory>
 
 #include <mpiwcpp17/environment.h>
 #include <mpiwcpp17/guard.hpp>
-#include <mpiwcpp17/global.hpp>
-#include <mpiwcpp17/communicator.hpp>
-#include <mpiwcpp17/window.hpp>
 #include <mpiwcpp17/info.hpp>
 
 MPIWCPP17_BEGIN_NAMESPACE
 
 namespace memory
 {
     /**
-     * Allocates speciallized memory for RMA operations. The allocated memory is
-     * not shared and thus can not be accessed directly by other processes.
+     * Allocates speciallized memory for RMA operations.
+     * The allocated memory is not shared and must be manually freed by the user.
      * @tparam T The type of the elements to store in the allocated memory region.
      * @param count The number of elements or bytes to allocate memory for each process.
      * @param info The key-value information instance to attach to allocated memory.
      * @return The smart pointer to the allocated region.
      */
     template <typename T = void>
-    MPIWCPP17_INLINE auto allocate(size_t count = 1, const info_t& info = info::null)
+    MPIWCPP17_INLINE T* allocate(size_t count = 1, const info_t& info = info::null)
     {
-        using element_t = std::conditional_t<std::is_void_v<T>, uint8_t, T>;
-        using region_t  = std::conditional_t<std::is_void_v<T>, void, element_t[]>;
-        constexpr size_t size = sizeof(element_t);
-
-        auto ptr = MPIWCPP17_GUARD_CALL(T*, MPI_Alloc_mem(count * size, info, &_));
-        auto fn  = [](T* ptr) -> void { guard(MPI_Free_mem(ptr)); };
-
-        return std::unique_ptr<region_t, decltype(fn)>(ptr, fn);
+        constexpr size_t size = sizeof(std::conditional_t<std::is_void_v<T>, uint8_t, T>);
+        return MPIWCPP17_GUARD_CALL(T*, MPI_Alloc_mem(count * size, info, &_));
     }
 
     /**
-     * Allocates contiguous memory for processes in a shared-memory communicator.
-     * The allocated memory region can be accessed directly by address from processes
-     * within the same physical node. Therefore, relative addesses can be calculated
-     * from variable known by each process individually.
-     * @tparam T The type of the elements to store in the allocated memory region.
-     * @param count The number of elements or bytes to allocate memory for each process.
-     * @param comm Communicator allowed for RMA operations with allocated memory.
-     * @param info The key-value information instance to attach to allocated memory.
-     * @return The smart pointer to the beginning of the shared memory region.
-     * @see mpi::window::allocate_shared
+     * Frees a manually allocated RMA-specialized memory region.
+     * Destructors must be manually called before freeing the memory, if necessary.
+     * @tparam T The type of the elements to stored the given memory region.
+     * @param ptr The pointer to the memory region to be released.
+     * @see mpi::memory::allocate
      */
     template <typename T = void>
-    MPIWCPP17_INLINE auto allocate_shared(
-        size_t count = 1
-      , const communicator_t& comm = world
-      , const info_t& info = info::null
-    ) {
-        using element_t = std::conditional_t<std::is_void_v<T>, uint8_t, T>;
-        using region_t  = std::conditional_t<std::is_void_v<T>, void, element_t[]>;
-
-        auto [base, w] = window::allocate_shared<T>(count, comm, info);
-        auto [gptr, _] = window::query_shared<T>(w, process::root);
-        auto fn        = [w = std::move(w)](T*) -> void {};
-
-        return std::unique_ptr<region_t, decltype(fn)>(gptr, std::move(fn));
+    MPIWCPP17_INLINE void free(T *ptr)
+    {
+        return MPIWCPP17_GUARD_EVAL(MPI_Free_mem(ptr));
     }
 }
 

src/mpiwcpp17/window.hpp

@@ -13,7 +13,6 @@
 #include <utility>
 
 #include <mpiwcpp17/environment.h>
-#include <mpiwcpp17/flag.hpp>
 #include <mpiwcpp17/guard.hpp>
 #include <mpiwcpp17/global.hpp>
 #include <mpiwcpp17/process.hpp>
@@ -51,23 +50,23 @@ struct window_t : MPIWCPP17_INHERIT_HANDLE(MPI_Win, MPI_Win_free);
  * @param B The call block to be wrapped.
  */
 #define MPIWCPP17_WIN_RAII(x)  window_t((x), true)
-#define MPIWCPP17_WIN_CALL(B)  MPIWCPP17_WIN_RAII(MPIWCPP17_GUARD_CALL(window_t, B))
+#define MPIWCPP17_WIN_CALL(B)  MPIWCPP17_WIN_RAII(MPIWCPP17_GUARD_CALL(MPI_Win, B))
 
 namespace window
 {
     /**
      * The invalid or empty window instance.
      * This can be used to verify whether a window is not in a valid state or to
      * denote an empty or uninitialized window.
-     * @since 3.0
+     * @since 2.1
      */
     MPIWCPP17_INLINE const window_t null = MPI_WIN_NULL;
 
     /**
      * Declares window attribute namespace and corresponding functions.
      * Attributes are identified by keys that can be used to attach and retrieve
      * generic data from window instances.
-     * @since 3.0
+     * @since 2.1
      */
     MPIWCPP17_ATTRIBUTE_DECLARE(
         window_t
@@ -80,66 +79,66 @@ namespace window
      * The window synchronization modes. These modes can be used to specify the type
      * of synchronization to be performed on a window when calling the corresponding
      * synchronization functions.
-     * @since 3.0
+     * @since 2.1
      */
     enum mode_t : int
     {
         /**
          * No special synchronization mode. This is the default synchronization mode
          * for all synchronization functions, no guarantees given whatsoever.
-         * @since 3.0
+         * @since 2.1
          */
         none       = 0
 
         /**
          * The mode for no preceding RMA operations. This mode indicates that no
          * RMA operations will be issued before synchronization.
-         * @since 3.0
+         * @since 2.1
          */
       , no_precede = MPI_MODE_NOPRECEDE
 
         /**
          * The mode for no preceding local stores or get calls. This mode indicates
          * that no local stores or get calls will be issued before synchronization.
-         * @since 3.0
+         * @since 2.1
          */
       , no_store   = MPI_MODE_NOSTORE
 
         /**
          * The mode for no updates by any put or accumulate calls. This mode indicates
          * that no put or accumulate calls will be performed until the next synchronization.
-         * @since 3.0
+         * @since 2.1
          */
       , no_put     = MPI_MODE_NOPUT
 
         /**
          * The mode for no succeeding RMA operations. This mode indicates that no
          * RMA operations will be issued after synchronization.
-         * @since 3.0
+         * @since 2.1
          */
       , no_succeed = MPI_MODE_NOSUCCEED
     };
 
     /**
      * The window lock types. These types can be used to specify the type of lock
      * to be acquired on a window when calling the corresponding lock functions.
-     * @since 3.0
+     * @since 2.1
      */
     enum lock_t : int
     {
         /**
          * The exclusive lock type. This lock type indicates that the calling process
          * will acquire an exclusive lock on the window, which prevents any other
          * process from performing access operations on the window.
-         * @since 3.0
+         * @since 2.1
          */
         exclusive = MPI_LOCK_EXCLUSIVE
 
         /**
          * The shared lock type. This lock type indicates that the calling process
          * will acquire a shared lock on the window, which allows other processes
          * to perform access operations as long as they also acquire a shared lock.
-         * @since 3.0
+         * @since 2.1
          */
       , shared    = MPI_LOCK_SHARED
     };
@@ -149,28 +148,22 @@ namespace window
      * instance enabling RMA communication. The amount of memory allocated may differ
      * between processes and is determined individually by its own parameters.
      * @tparam T The type of the elements to store in the allocated memory region.
-     * @tparam G The flag to determine the type of allocated memory.
      * @param count The number of elements or bytes to allocate for each process.
      * @param comm Communicator allowed for RMA operations with allocated memory.
      * @param info The key-value information instance to attach to allocated memory.
      * @return The allocated memory pointer and new window instance.
      */
-    template <
-        typename T = void
-      , typename G = flag::window::local_t>
+    template <typename T = void>
     MPIWCPP17_INLINE std::pair<T*, window_t> allocate(
         size_t count = 1
       , const communicator_t& comm = world
       , const info_t& info = info::null
-      , G = {}
     ) {
-        T *ptr;
         constexpr size_t size = sizeof(std::conditional_t<std::is_void_v<T>, uint8_t, T>);
-        auto w = MPIWCPP17_WIN_CALL((
-            std::is_same_v<flag::window::shared_t, G>
-                ? MPI_Win_allocate_shared(count * size, size, info, comm, &ptr, &_)
-                : MPI_Win_allocate(count * size, size, info, comm, &ptr, &_)));
-        return std::make_pair(ptr, std::move(w));
+        auto result = MPIWCPP17_GUARD_CALL(
+            struct { T *ptr; window_t::raw_t w; }
+          , MPI_Win_allocate(count * size, size, info, comm, &_.ptr, &_.w));
+        return std::make_pair(result.ptr, MPIWCPP17_WIN_RAII(result.w));
     }
 
     /**
@@ -190,7 +183,11 @@ namespace window
       , const communicator_t& comm = world
       , const info_t& info = info::null
     ) {
-        return allocate<T, flag::window::shared_t>(count, comm, info);
+        constexpr size_t size = sizeof(std::conditional_t<std::is_void_v<T>, uint8_t, T>);
+        auto result = MPIWCPP17_GUARD_CALL(
+            struct { T *ptr; window_t::raw_t w; }
+          , MPI_Win_allocate_shared(count * size, size, info, comm, &_.ptr, &_.w));
+        return std::make_pair(result.ptr, MPIWCPP17_WIN_RAII(result.w));
     }
 
     /**
@@ -236,7 +233,7 @@ namespace window
      * @param info The key-value information instance to attach to the new window.
      * @return The new window instance that manages a memory regions attached dynamically.
      */
-    MPIWCPP17_INLINE window_t create_dynamic(
+    MPIWCPP17_INLINE window_t create(
         const communicator_t& comm = world
       , const info_t& info = info::null
     ) {