RangeSegment.hpp

Go to the documentation of this file.

 
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~//
// Copyright (c) Lawrence Livermore National Security, LLC and other
// RAJA Project Developers. See top-level LICENSE and COPYRIGHT
// files for dates and other details. No copyright assignment is required
// to contribute to RAJA.
//
// SPDX-License-Identifier: (BSD-3-Clause)
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~//
 
#ifndef RAJA_RangeSegment_HPP
#define RAJA_RangeSegment_HPP
 
#include "RAJA/config.hpp"
 
#include <iostream>
 
#include "RAJA/internal/Iterators.hpp"
 
#include "RAJA/util/concepts.hpp"
 
#include "RAJA/index/IndexValue.hpp"
 
namespace RAJA
{
 
template<typename StorageT,
         typename DiffT = make_signed_t<strip_index_type_t<StorageT>>>
struct TypedRangeSegment
{
 
  //
  // Static asserts to provide some useful error messages during compilation
  // for incorrect usage.
  //
  static_assert(std::is_signed<DiffT>::value,
                "TypedRangeSegment DiffT requires signed type.");
  static_assert(!std::is_floating_point<StorageT>::value,
                "TypedRangeSegment Type must be non floating point.");
 
 
  using iterator = Iterators::numeric_iterator<StorageT, DiffT>;
 
  using value_type = StorageT;
 
  using IndexType = DiffT;
 
 
 
  using StripStorageT = strip_index_type_t<StorageT>;
 
  RAJA_HOST_DEVICE constexpr TypedRangeSegment(StripStorageT begin,
                                               StripStorageT end)
      : m_begin(iterator(begin)),
        m_end(begin > end ? m_begin : iterator(end))
  {}
 
  RAJA_HOST_DEVICE TypedRangeSegment() = delete;
 
  constexpr TypedRangeSegment(TypedRangeSegment&&) = default;
 
  constexpr TypedRangeSegment(TypedRangeSegment const&) = default;
 
  RAJA_INLINE TypedRangeSegment& operator=(TypedRangeSegment const&) = default;
 
  RAJA_INLINE ~TypedRangeSegment() = default;
 
 
 
  RAJA_HOST_DEVICE RAJA_INLINE iterator begin() const { return m_begin; }
 
  RAJA_HOST_DEVICE RAJA_INLINE iterator end() const { return m_end; }
 
  RAJA_HOST_DEVICE RAJA_INLINE DiffT size() const { return m_end - m_begin; }
 
 
 
  RAJA_HOST_DEVICE RAJA_INLINE bool operator==(TypedRangeSegment const& o) const
  {
    // someday this shall be replaced with a compiler-generated operator==
    return m_begin == o.m_begin && m_end == o.m_end;
  }
 
  RAJA_HOST_DEVICE RAJA_INLINE bool operator!=(TypedRangeSegment const& o) const
  {
    return !(operator==(o));
  }
 
 
  RAJA_HOST_DEVICE RAJA_INLINE TypedRangeSegment slice(StorageT begin,
                                                       DiffT length) const
  {
    StorageT start = m_begin[0] + begin;
    StorageT end   = start + length > m_end[0] ? m_end[0] : start + length;
 
    return TypedRangeSegment {stripIndexType(start), stripIndexType(end)};
  }
 
  RAJA_HOST_DEVICE RAJA_INLINE void swap(TypedRangeSegment& other)
  {
    camp::safe_swap(m_begin, other.m_begin);
    camp::safe_swap(m_end, other.m_end);
  }
 
private:
  // Member variable for begin iterator
  iterator m_begin;
 
  // Member variable for end iterator
  iterator m_end;
};
 
template<typename StorageT,
         typename DiffT = make_signed_t<strip_index_type_t<StorageT>>>
struct TypedRangeStrideSegment
{
 
  //
  // Static asserts to provide some useful error messages during compilation
  // for incorrect usage.
  //
  static_assert(std::is_signed<DiffT>::value,
                "TypedRangeStrideSegment DiffT requires signed type.");
  static_assert(!std::is_floating_point<StorageT>::value,
                "TypedRangeStrideSegment Type must be non floating point.");
 
 
  using iterator = Iterators::strided_numeric_iterator<StorageT, DiffT>;
 
  using value_type = StorageT;
 
  using IndexType = DiffT;
 
 
 
  using StripStorageT = strip_index_type_t<StorageT>;
 
  RAJA_HOST_DEVICE TypedRangeStrideSegment(StripStorageT begin,
                                           StripStorageT end,
                                           DiffT stride)
      : m_begin(iterator(begin, stride)),
        m_end(iterator(end, stride)),
        // essentially a ceil((end-begin)/stride) but using integer math,
        // and allowing for negative strides
        m_size((end - begin + stride - (stride > 0 ? 1 : -1)) / stride)
  {
    // clamp range when end is unreachable from begin without wrapping
    if (stride < 0 && end > begin)
    {
      m_end = m_begin;
    }
    else if (stride > 0 && end < begin)
    {
      m_end = m_begin;
    }
    // m_size initialized as negative indicates a zero iteration space
    m_size = m_size < DiffT {0} ? DiffT {0} : m_size;
  }
 
  TypedRangeStrideSegment() = delete;
 
  TypedRangeStrideSegment(TypedRangeStrideSegment&&) = default;
 
  TypedRangeStrideSegment(TypedRangeStrideSegment const&) = default;
 
  TypedRangeStrideSegment& operator=(TypedRangeStrideSegment const&) = default;
 
  ~TypedRangeStrideSegment() = default;
 
 
 
  RAJA_HOST_DEVICE iterator begin() const { return m_begin; }
 
  RAJA_HOST_DEVICE iterator end() const { return m_end; }
 
  RAJA_HOST_DEVICE DiffT size() const { return m_size; }
 
 
 
  RAJA_HOST_DEVICE bool operator==(TypedRangeStrideSegment const& o) const
  {
    // someday this shall be replaced with a compiler-generated operator==
    return m_begin == o.m_begin && m_end == o.m_end && m_size == o.m_size;
  }
 
  RAJA_HOST_DEVICE RAJA_INLINE bool operator!=(
      TypedRangeStrideSegment const& o) const
  {
    return !(operator==(o));
  }
 
 
  RAJA_HOST_DEVICE TypedRangeStrideSegment slice(StorageT begin,
                                                 DiffT length) const
  {
    StorageT stride = m_begin.get_stride();
    StorageT start  = m_begin[0] + begin * stride;
    StorageT end    = start + stride * length;
 
    if (stride > 0)
    {
      end = end > m_end[0] ? m_end[0] : end;
    }
    else
    {
      end = end < m_end[0] ? m_end[0] : end;
    }
 
    return TypedRangeStrideSegment {stripIndexType(start), stripIndexType(end),
                                    m_begin.get_stride()};
  }
 
  RAJA_HOST_DEVICE void swap(TypedRangeStrideSegment& other)
  {
    camp::safe_swap(m_begin, other.m_begin);
    camp::safe_swap(m_end, other.m_end);
    camp::safe_swap(m_size, other.m_size);
  }
 
private:
  // Member variable for begin iterator
  iterator m_begin;
 
  // Member variable for end iterator
  iterator m_end;
 
  // Member variable for size of segment
  DiffT m_size;
};
 
using RangeSegment = TypedRangeSegment<Index_type>;
 
using RangeStrideSegment = TypedRangeStrideSegment<Index_type>;
 
namespace detail
{
 
template<typename T, typename... Rest>
struct common_type
    : std::common_type<T, typename std::common_type<Rest...>::type>
{};
 
template<typename T>
struct common_type<T>
{
  using type = T;
};
 
template<typename... Ts>
using common_type_t = typename common_type<Ts...>::type;
 
}  // namespace detail
 
template<typename BeginT,
         typename EndT,
         typename Common = detail::common_type_t<BeginT, EndT>>
RAJA_HOST_DEVICE TypedRangeSegment<Common> make_range(BeginT&& begin,
                                                      EndT&& end)
{
  return {begin, end};
}
 
template<typename BeginT,
         typename EndT,
         typename StrideT,
         typename Common = detail::common_type_t<BeginT, EndT>>
RAJA_HOST_DEVICE TypedRangeStrideSegment<Common> make_strided_range(
    BeginT&& begin,
    EndT&& end,
    StrideT&& stride)
{
  static_assert(std::is_signed<StrideT>::value,
                "make_strided_segment : stride must be signed.");
  static_assert(
      std::is_same<make_signed_t<EndT>, StrideT>::value,
      "make_stride_segment : stride and end must be of similar types.");
  return {begin, end, stride};
}
 
namespace concepts
{
 
template<typename T, typename U>
struct RangeConstructible
    : DefineConcept(camp::val<RAJA::detail::common_type_t<T, U>>()) {};
 
template<typename T, typename U, typename V>
struct RangeStrideConstructible
    : DefineConcept(camp::val<RAJA::detail::common_type_t<T, U, V>>()) {};
 
}  // namespace concepts
 
namespace type_traits
{
 
DefineTypeTraitFromConcept(is_range_constructible,
                           RAJA::concepts::RangeConstructible);
 
DefineTypeTraitFromConcept(is_range_stride_constructible,
                           RAJA::concepts::RangeStrideConstructible);
 
}  // namespace type_traits
 
}  // namespace RAJA
 
namespace std
{
 
template<typename T>
RAJA_HOST_DEVICE RAJA_INLINE void swap(RAJA::TypedRangeSegment<T>& a,
                                       RAJA::TypedRangeSegment<T>& b)
{
  a.swap(b);
}
 
template<typename T>
RAJA_HOST_DEVICE RAJA_INLINE void swap(RAJA::TypedRangeStrideSegment<T>& a,
                                       RAJA::TypedRangeStrideSegment<T>& b)
{
  a.swap(b);
}
 
}  // namespace std
 
#endif  // closing endif for header file include guard