[WIP] Finish Global Dynamic Memory and Allocator Concepts

dart-if/include/dash/dart/if/dart_globmem.h

@@ -19,6 +19,9 @@
 extern "C" {
 #endif
 
+#include <dash/dart/if/dart_types.h>
+#include <dash/dart/if/dart_team_group.h>
+
 /** \cond DART_HIDDEN_SYMBOLS */
 #define DART_INTERFACE_ON
 /** \endcond */
@@ -57,23 +60,43 @@ extern "C" {
 
   */
 
-  /*
- PROPOSAL: use 128 bit global pointers with the following layout:
+/*
+PROPOSAL: use 128 bit global pointers with the following layout:
 
 
  0       1       2       3       4       5       6       7
  0123456701234567012345670123456701234567012345670123456701234567
  |----<24 bit unit id>---|-flags-|-<segment id>--|---<team id>--|
  |-----------<64 bit virtual address or offset>-----------------|
+*/
 
-  */
+/**
+ * Test for NULL global pointer
+ *
+ * \ingroup DartGlobMem
+ */
+#define DART_GPTR_ISNULL(gptr_)         \
+  (gptr_.unitid<0 && gptr_.segid==0 &&  \
+   gptr_.teamid==DART_TEAM_NULL   &&    \
+   gptr_.addr_or_offs.addr==0)
 
+/**
+ * Compare two global pointers
+ *
+ * \ingroup DartGlobMem
+ */
+#define DART_GPTR_EQUAL(gptr1_, gptr2_ )    \
+  ((gptr1_.unitid == gptr2_.unitid) &&      \
+   (gptr1_.segid  == gptr2_.segid)  &&      \
+   (gptr1_.teamid == gptr2_.teamid) &&      \
+   (gptr1_.addr_or_offs.offset ==           \
+    gptr2_.addr_or_offs.offset) )
 /**
  * DART Global pointer type.
  *
  * \ingroup DartGlobMem
  */
-typedef struct
+typedef struct dart_gptr
 {
   /**
    * The unit holding the memory element.
@@ -90,8 +113,20 @@ typedef struct
   union
   {
     uint64_t offset;
-    void*    addr;
+    void *addr;
   } addr_or_offs;
+#ifdef __cplusplus
+  explicit operator bool() const noexcept { return !DART_GPTR_ISNULL((*this)); }
+
+  bool operator==(const dart_gptr &rhs) const noexcept
+  {
+    return DART_GPTR_EQUAL((*this), rhs);
+  }
+  bool operator!=(const dart_gptr &rhs) const noexcept
+  {
+    return !(*this == rhs);
+  }
+#endif
 } dart_gptr_t;
 
 /**
@@ -109,27 +144,6 @@ typedef struct
                .addr_or_offs.offset = 0 }
 #endif
 
-/**
- * Test for NULL global pointer
- *
- * \ingroup DartGlobMem
- */
-#define DART_GPTR_ISNULL(gptr_)         \
-  (gptr_.unitid<0 && gptr_.segid==0 &&  \
-   gptr_.teamid==DART_TEAM_NULL   &&    \
-   gptr_.addr_or_offs.addr==0)
-
-/**
- * Compare two global pointers
- *
- * \ingroup DartGlobMem
- */
-#define DART_GPTR_EQUAL(gptr1_, gptr2_ )    \
-  ((gptr1_.unitid == gptr2_.unitid) &&      \
-   (gptr1_.segid  == gptr2_.segid)  &&      \
-   (gptr1_.teamid == gptr2_.teamid) &&      \
-   (gptr1_.addr_or_offs.offset ==           \
-    gptr2_.addr_or_offs.offset) )
 
 
 /**
@@ -410,7 +424,6 @@ dart_ret_t dart_team_memregister(
  */
 dart_ret_t dart_team_memderegister(dart_gptr_t gptr) DART_NOTHROW;
 
-
 /** \cond DART_HIDDEN_SYMBOLS */
 #define DART_INTERFACE_OFF
 /** \endcond */
@@ -420,4 +433,3 @@ dart_ret_t dart_team_memderegister(dart_gptr_t gptr) DART_NOTHROW;
 #endif
 
 #endif /* DART_GLOBMEM_H_INCLUDED */
-

dash/include/dash/Allocator.h

@@ -1,10 +1,15 @@
 #ifndef DASH__ALLOCATOR_H__INCLUDED
 #define DASH__ALLOCATOR_H__INCLUDED
 
+#include <dash/allocator/AllocatorTraits.h>
+
 #include <dash/allocator/LocalAllocator.h>
 #include <dash/allocator/SymmetricAllocator.h>
 #include <dash/allocator/EpochSynchronizedAllocator.h>
 
+
+#include <dash/memory/SimpleMemoryPool.h>
+
 namespace dash {
 
 /**

dash/include/dash/GlobPtr.h

@@ -19,14 +19,6 @@ std::ostream & operator<<(
   std::ostream      & os,
   const dart_gptr_t & dartptr);
 
-bool operator==(
-  const dart_gptr_t & lhs,
-  const dart_gptr_t & rhs);
-
-bool operator!=(
-  const dart_gptr_t & lhs,
-  const dart_gptr_t & rhs);
-
 namespace dash {
 
 // Forward-declarations
@@ -489,6 +481,9 @@ class GlobPtr
     return _rbegin_gptr.unitid == luid.id;
   }
 
+  constexpr explicit operator bool() const noexcept {
+    return !DART_GPTR_ISNULL(_rbegin_gptr);
+  }
 private:
   void increment(index_type offs) {
     auto ptr_offset = _rbegin_gptr.addr_or_offs.offset / sizeof(value_type);
@@ -558,7 +553,7 @@ std::ostream & operator<<(
 
 /**
  * Internal type.
- * 
+ *
  * Specialization of \c dash::GlobPtr, wraps underlying global address
  * as global const pointer (not pointer to const).
  *
@@ -838,7 +833,7 @@ dash::gptrdiff_t distance(
  * \complexity  O(1)
  *
  * \ingroup     Algorithms
- * 
+ *
  * \concept{DashMemorySpaceConcept}
  */
 template<typename ElementType, class MemSpaceT>

dash/include/dash/Types.h

@@ -1,12 +1,13 @@
 #ifndef DASH__TYPES_H_
 #define DASH__TYPES_H_
 
-#include <array>
-#include <type_traits>
-
 #include <dash/dart/if/dart_types.h>
 #include <dash/internal/Unit.h>
 
+#include <array>
+#include <cstddef>
+#include <type_traits>
+
 
 namespace dash {
 
@@ -300,6 +301,17 @@ constexpr team_unit_t   UNDEFINED_TEAM_UNIT_ID{DART_UNDEFINED_UNIT_ID};
  */
 constexpr global_unit_t UNDEFINED_GLOBAL_UNIT_ID{DART_UNDEFINED_UNIT_ID};
 
+
+typedef
+#if defined(__clang__)
+  // clang has issues finding a definition for std::max_align_t,
+  // usually it is synonymous with the largest scalar type.
+  long double
+#else
+  typename std::max_align_t
+#endif
+  max_align_t;
+
 } // namespace dash
 
 #endif // DASH__TYPES_H_

dash/include/dash/UnorderedMap.h

@@ -182,9 +182,9 @@ class UnorderedMap
   typedef typename glob_mem_type::const_reverse_local_iterator
     const_reverse_local_node_iterator;
 
-  typedef typename glob_mem_type::global_iterator
+  typedef typename glob_mem_type::local_iterator
     local_node_pointer;
-  typedef typename glob_mem_type::const_global_iterator
+  typedef typename glob_mem_type::const_local_iterator
     const_local_node_pointer;
 
   typedef UnorderedMapGlobIter<Key, Mapped, Hash, Pred, Alloc>
@@ -550,6 +550,28 @@ class UnorderedMap
     /// The element to insert.
     const value_type & value);
 
+  /**
+   * inserts value, using hint as a non-binding suggestion to where the search should start.
+   *
+   * Iterator validity:
+   *
+   * - All iterators in the container remain valid after the insertion unless
+   *   it forces a rehash. In this case, all iterators in the container are
+   *   invalidated.
+   * - A rehash is forced if the new container size after the insertion
+   *   operation would increase above its capacity threshold.
+   * - References to elements in the map container remain valid in all cases,
+   *   even after a rehash.
+   *
+   * \return  an iterator to the inserted element, or to the element that prevented the
+   *          insertion.
+   */
+  iterator insert(
+    //Iterator hint
+    const_iterator hint,
+    //The element to insert
+    const value_type & value);
+
   /**
    * Insert elements in iterator range of key-value pairs, increasing the
    * container size by the number of elements in the range.

dash/include/dash/allocator/AllocatorTraits.h

@@ -0,0 +1,69 @@
+#ifndef DASH__ALLOCATOR__ALLOCATOR_TRAITS_H__INCLUDED
+#define DASH__ALLOCATOR__ALLOCATOR_TRAITS_H__INCLUDED
+
+#include <dash/memory/MemorySpace.h>
+
+#include <memory>
+
+namespace dash {
+
+struct collective_allocator_tag {
+};
+
+struct noncollective_allocator_tag {
+};
+
+template <class Allocator>
+struct allocator_traits {
+
+  typedef Allocator allocator_type;
+
+  typedef typename allocator_type::allocator_category allocator_category;
+  typedef typename allocator_type::local_pointer local_pointer;
+
+  //
+  typedef typename allocator_type::value_type value_type;
+  typedef typename allocator_type::pointer pointer;
+
+  /*
+  typedef
+      typename dash::pointer_traits<pointer>::template rebind<const value_type>
+          const_pointer;
+  typedef typename dash::pointer_traits<pointer>::template rebind<void>
+      void_pointer;
+  typedef typename dash::pointer_traits<pointer>::template rebind<const void>
+      const_void_pointer;
+      */
+
+  typedef typename allocator_type::const_pointer const_pointer;
+  typedef typename allocator_type::void_pointer void_pointer;
+  typedef typename allocator_type::const_void_pointer const_void_pointer;
+
+  typedef typename allocator_type::difference_type difference_type;
+  typedef typename allocator_type::size_type size_type;
+
+  /*
+  typedef
+      typename dash::pointer_traits<pointer>::difference_type difference_type;
+  typedef typename std::make_unsigned<difference_type>::type size_type;
+  */
+
+  template <class U>
+  using rebind_alloc = typename allocator_type::template rebind<U>::other;
+
+  template <class U>
+  using rebind_traits =
+      dash::allocator_traits<rebind_alloc<U>>;
+
+
+  static pointer allocate(allocator_type& a, size_type n)
+      { return a.allocate(n); }
+
+  static void deallocate(allocator_type& a, pointer p, size_type n)
+      { a.deallocate(p, n); }
+
+};
+
+}  // namespace dash
+
+#endif  // DASH__ALLOCATOR__ALLOCATOR_TRAITS_H__INCLUDED