[WIP] Fixing and improving algorithms with view expressions

.gitignore

@@ -21,7 +21,7 @@ dash/include/dash/util/StaticConfig.h
 *.log
 *.out
 ipm/*/GEN.*
-my.*.sh
+my.*
 .syntastic*
 .clang*
 tags

dash/include/dash/Cartesian.h

@@ -251,16 +251,16 @@ class CartesianIndexSpace
   typedef SizeType                            size_type;
   typedef std::array<SizeType, NumDimensions> extents_type;
 
-  template<dim_t NDim_>
+  template<dim_t NDim_, MemArrange MA_, typename Ix_>
   friend std::ostream & operator<<(
-    std::ostream                     & os,
-    const CartesianIndexSpace<NDim_> & cartesian_space);
+    std::ostream                               & os,
+    const CartesianIndexSpace<NDim_, MA_, Ix_> & cartesian_space);
 
 protected:
   /// Number of elements in the cartesian space spanned by this instance.
   SizeType     _size             = 0;
   /// Number of dimensions in the cartesian space.
-  SizeType     _rank             = NumDimensions;
+  SizeType     _rank             = 0;
   /// Extents of the cartesian space by dimension.
   extents_type _extents          = {  };
   /// Cumulative index offsets of the index space by dimension respective
@@ -348,12 +348,10 @@ class CartesianIndexSpace
    */
   template<typename... Args>
   void resize(SizeType arg, Args... args) {
-    static_assert(
-      sizeof...(Args) == NumDimensions-1,
-      "Invalid number of arguments");
-    std::array<SizeType, NumDimensions> extents =
-      {{ arg, (SizeType)(args)... }};
-    resize(extents);
+    resize(
+      std::array<SizeType, NumDimensions> {{
+        arg, (SizeType)(args)...
+      }} );
   }
 
   /**
@@ -363,9 +361,18 @@ class CartesianIndexSpace
   void resize(const std::array<SizeType_, NumDimensions> & extents) {
     // Update size:
     _size = 1;
+    _rank = 0;
     for(auto i = 0; i < NumDimensions; i++ ) {
       _extents[i] = static_cast<SizeType>(extents[i]);
       _size      *= _extents[i];
+      if (_extents[i] > 1) {
+        ++_rank;
+      }
+    }
+    if (_size == 0) {
+      _rank = 0;
+    } else if (_rank == 0) {
+      _rank = 1;
     }
     // Update offsets:
     _offset_row_major[NumDimensions-1] = 1;
@@ -805,17 +812,16 @@ std::ostream & operator<<(
   return operator<<(os, ss.str());
 }
 
-template <
-  dash::dim_t NumDimensions >
+template<dim_t NDim_, MemArrange MA_, typename Ix_>
 std::ostream & operator<<(
-  std::ostream & os,
-  const dash::CartesianIndexSpace<NumDimensions> & cartesian_space)
+    std::ostream                               & os,
+    const CartesianIndexSpace<NDim_, MA_, Ix_> & cartesian_space)
 {
   std::ostringstream ss;
   ss << dash::typestr(cartesian_space)
      << ": "
      << "extents(";
-  for (auto dim = 0; dim < NumDimensions; ++dim) {
+  for (auto dim = 0; dim < NDim_; ++dim) {
     if (dim > 0) {
       ss << ",";
     }

dash/include/dash/Exception.h

@@ -1,17 +1,21 @@
 #ifndef DASH__EXCEPTION_H_
 #define DASH__EXCEPTION_H_
 
+#include <dash/internal/Macro.h>
+#include <dash/internal/Logging.h>
+
 #include <dash/exception/RuntimeError.h>
 #include <dash/exception/InvalidArgument.h>
 #include <dash/exception/OutOfRange.h>
 #include <dash/exception/NotImplemented.h>
 #include <dash/exception/AssertionFailed.h>
 #include <dash/exception/StackTrace.h>
 
-#include <dash/internal/Macro.h>
-#include <dash/internal/Logging.h>
+#include <dash/Init.h>
 
 #include <sstream>
+#include <iostream>
+
 
 #define DASH_STACK_TRACE() do { \
     dash__print_stacktrace(); \

dash/include/dash/GlobPtr.h

@@ -39,14 +39,6 @@ template <typename T>                  class GlobConstPtr;
 
 template <typename T, class MemSpaceT> class GlobPtr;
 
-template <typename T1,
-          typename T2,
-          class    MemSpaceT1,
-          class    MemSpaceT2 >
-dash::gptrdiff_t distance(
-  const GlobPtr<T1, MemSpaceT1> & gbegin,
-  const GlobPtr<T2, MemSpaceT2> & gend);
-
 /**
  * Pointer in global memory space with random access arithmetics.
  *
@@ -72,7 +64,11 @@ class GlobPtr
   typedef GlobPtr<const ElementType, MemorySpace>      const_type;
   typedef typename dash::default_index_t               index_type;
 
+  typedef value_type *                                 local_type;
+  typedef self_t                                      global_type;
+
   typedef index_type                                   gptrdiff_t;
+  typedef index_type                              difference_type;
 
 public:
   template <typename T, class MemSpaceT>
@@ -269,10 +265,57 @@ class GlobPtr
 
   /**
    * Pointer offset difference operator.
+   *
+   * Defined with independent value types allow calculation
+   * of distance between \c GlobPtr<T> and \c GlobPtr<const T>.
+   * Refernced value types must have identical size.
+   *
+   * \todo
+   * Validate compatibility of memory space types using memory space traits
+   * once they are available.
+   *
+   * \return  Global pointer distance between the first and second
+   *          global pointer, corresponds to pointer distance
+   *          \c (gend - gbegin)
+   *
+   * \concept{DashMemorySpaceConcept}
    */
-  constexpr index_type operator-(const self_t & rhs) const noexcept
+  template <typename TO, class MemSpaceTO >
+  difference_type operator-(
+    const GlobPtr<TO, MemSpaceTO> & rhs) const noexcept
   {
-    return dash::distance(rhs, *this);
+    using val_type_b = typename std::decay<decltype(rhs)>::type::value_type;
+    using val_type_e = value_type;
+
+    static_assert(
+      sizeof(val_type_b) == sizeof(val_type_e),
+      "value types of global pointers are not compatible for dash::distance");
+
+    // Both pointers in same unit space:
+    if (rhs._rbegin_gptr.unitid == _rbegin_gptr.unitid ||
+        rhs._mem_space == nullptr) {
+      return ( _rbegin_gptr.addr_or_offs.offset -
+               rhs._rbegin_gptr.addr_or_offs.offset )
+             / sizeof(value_type);
+    }
+    // If unit of begin pointer is after unit of end pointer,
+    // return negative distance with swapped argument order:
+    if (rhs._rbegin_gptr.unitid > _rbegin_gptr.unitid) {
+      return -(rhs - *this);
+    }
+    // Pointers span multiple unit spaces, accumulate sizes of
+    // local unit memory ranges in the pointer range:
+    index_type dist =   rhs._mem_space->local_size(
+                          dart_team_unit_t { rhs.dart_gptr().unitid })
+                      - (rhs.dart_gptr().addr_or_offs.offset
+                          / sizeof(value_type))
+                      + (dart_gptr().addr_or_offs.offset
+                          / sizeof(value_type));
+    for (int u = rhs.dart_gptr().unitid+1;
+             u < dart_gptr().unitid; ++u) {
+      dist += _mem_space->local_size(dart_team_unit_t { u });
+    }
+    return dist;
   }
 
   /**
@@ -581,6 +624,9 @@ class GlobConstPtr
   typedef typename base_t::index_type                  index_type;
   typedef typename base_t::gptrdiff_t                  gptrdiff_t;
 
+  typedef value_type *                                 local_type;
+  typedef self_t                                      global_type;
+
   template <typename T_>
   friend std::ostream & operator<<(
     std::ostream           & os,
@@ -766,70 +812,6 @@ std::ostream & operator<<(
 
 #endif // DOXYGEN
 
-/**
- * Specialization of \c dash::distance for \c dash::GlobPtr as default
- * definition of pointer distance in global memory spaces.
- *
- * Equivalent to \c (gend - gbegin).
- *
- * \note
- * Defined with independent value types T1 and T2 to allow calculation
- * of distance between \c GlobPtr<T> and \c GlobPtr<const T>.
- * The pointer value types must have identical size.
- *
- * \todo
- * Validate compatibility of memory space types using memory space traits
- * once they are available.
- *
- * \return  Number of elements in the range between the first and second
- *          global pointer
- *
- * \concept{DashMemorySpaceConcept}
- */
-template <typename T1,
-          typename T2,
-          class    MemSpaceT1,
-          class    MemSpaceT2 >
-dash::gptrdiff_t distance(
-  // First global pointer in range
-  const GlobPtr<T1, MemSpaceT1> & gbegin,
-  // Final global pointer in range
-  const GlobPtr<T2, MemSpaceT2> & gend) {
-  using index_type = dash::gptrdiff_t;
-  using val_type_b = typename std::decay<decltype(gbegin)>::type::value_type;
-  using val_type_e = typename std::decay<decltype(gend)>::type::value_type;
-  using value_type = val_type_b;
-
-  static_assert(
-    sizeof(val_type_b) == sizeof(val_type_e),
-    "value types of global pointers are not compatible for dash::distance");
-
-  // Both pointers in same unit space:
-  if (gbegin._rbegin_gptr.unitid == gend._rbegin_gptr.unitid ||
-      gbegin._mem_space == nullptr) {
-    return ( gend._rbegin_gptr.addr_or_offs.offset -
-             gbegin._rbegin_gptr.addr_or_offs.offset )
-           / sizeof(value_type);
-  }
-  // If unit of begin pointer is after unit of end pointer,
-  // return negative distance with swapped argument order:
-  if (gbegin._rbegin_gptr.unitid > gend._rbegin_gptr.unitid) {
-    return -(dash::distance(gend, gbegin));
-  }
-  // Pointers span multiple unit spaces, accumulate sizes of
-  // local unit memory ranges in the pointer range:
-  index_type dist = gbegin._mem_space->local_size(
-                      dart_team_unit_t { gbegin.dart_gptr().unitid })
-                    - (gbegin.dart_gptr().addr_or_offs.offset
-                        / sizeof(value_type))
-                    + (gend.dart_gptr().addr_or_offs.offset
-                        / sizeof(value_type));
-  for (int u = gbegin.dart_gptr().unitid+1;
-           u < gend.dart_gptr().unitid; ++u) {
-    dist += gend._mem_space->local_size(dart_team_unit_t { u });
-  }
-  return dist;
-}
 
 /**
  * Resolve the number of elements between two global pointers.

dash/include/dash/Meta.h

@@ -71,6 +71,12 @@ DASH__META__DEFINE_TRAIT__HAS_TYPE(const_reference);
  */
 DASH__META__DEFINE_TRAIT__HAS_TYPE(value_type);
 
+/**
+ * Definition of type trait \c dash::detail::has_type_pattern_type<T>
+ * with static member \c value indicating whether type \c T provides
+ * dependent type \c pattern_type.
+ */
+DASH__META__DEFINE_TRAIT__HAS_TYPE(pattern_type);
 
 } // namespace dash