ListSegment.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_ListSegment_HPP
#define RAJA_ListSegment_HPP
 
#include "RAJA/config.hpp"
 
#include <memory>
#include <type_traits>
#include <utility>
 
#include "camp/resource.hpp"
 
#include "RAJA/util/concepts.hpp"
#include "RAJA/util/macros.hpp"
#include "RAJA/util/Span.hpp"
#include "RAJA/util/types.hpp"
 
namespace RAJA
{
 
template<typename StorageT>
class TypedListSegment
{
public:
 
  using value_type = StorageT;
 
  using iterator = StorageT*;
 
  using IndexType = StorageT;
 
 
 
  TypedListSegment(const value_type* values,
                   Index_type length,
                   camp::resources::Resource resource,
                   IndexOwnership owned = Owned)
      : m_resource(nullptr),
        m_owned(Unowned),
        m_data(nullptr),
        m_size(0)
  {
    initIndexData(values, length, resource, owned);
  }
 
  template<typename Container>
  TypedListSegment(const Container& container,
                   camp::resources::Resource resource)
      : m_resource(nullptr),
        m_owned(Unowned),
        m_data(nullptr),
        m_size(container.size())
  {
    if (m_size > 0)
    {
 
      camp::resources::Resource host_res {camp::resources::Host::get_default()};
 
      value_type* tmp = host_res.allocate<value_type>(m_size);
 
      auto dest      = tmp;
      auto src       = container.begin();
      auto const end = container.end();
      while (src != end)
      {
        *dest = *src;
        ++dest;
        ++src;
      }
 
      m_resource = new camp::resources::Resource(resource);
      m_data     = m_resource->allocate<value_type>(m_size);
      m_resource->memcpy(m_data, tmp, sizeof(value_type) * m_size);
      m_resource->wait();
      m_owned = Owned;
 
      host_res.deallocate(tmp);
    }
  }
 
  TypedListSegment() = delete;
 
  //  As this may be called from a lambda in a
  //  RAJA method we perform a shallow copy
  RAJA_HOST_DEVICE TypedListSegment(const TypedListSegment& other)
      : m_resource(nullptr),
        m_owned(Unowned),
        m_data(other.m_data),
        m_size(other.m_size)
  {}
 
  //  As this may be called from a lambda in a
  //  RAJA method we perform a shallow copy
  RAJA_HOST_DEVICE TypedListSegment& operator=(const TypedListSegment& other)
  {
    clear();
    m_resource = nullptr;
    m_owned    = Unowned;
    m_data     = other.m_data;
    m_size     = other.m_size;
  }
 
  //  As this may be called from a lambda in a
  //  RAJA method we perform a shallow copy
  RAJA_HOST_DEVICE TypedListSegment& operator=(TypedListSegment&& rhs)
  {
    clear();
    m_resource = rhs.m_resource;
    m_owned    = rhs.m_owned;
    m_data     = rhs.m_data;
    m_size     = rhs.m_size;
 
    rhs.m_resource = nullptr;
    rhs.m_owned    = Unowned;
    rhs.m_data     = nullptr;
    rhs.m_size     = 0;
  }
 
  RAJA_HOST_DEVICE TypedListSegment(TypedListSegment&& rhs)
      : m_resource(rhs.m_resource),
        m_owned(rhs.m_owned),
        m_data(rhs.m_data),
        m_size(rhs.m_size)
  {
    rhs.m_owned    = Unowned;
    rhs.m_resource = nullptr;
    rhs.m_size     = 0;
    rhs.m_data     = nullptr;
  }
 
  RAJA_HOST_DEVICE ~TypedListSegment() { clear(); }
 
  RAJA_HOST_DEVICE void clear()
  {
 
#if !defined(RAJA_GPU_DEVICE_COMPILE_PASS_ACTIVE)
    if (m_data != nullptr && m_owned == Owned)
    {
      m_resource->deallocate(m_data);
      delete m_resource;
    }
#endif
    m_data     = nullptr;
    m_resource = nullptr;
    m_owned    = Unowned;
    m_size     = 0;
  }
 
 
 
  RAJA_HOST_DEVICE iterator begin() const { return m_data; }
 
  RAJA_HOST_DEVICE iterator end() const { return m_data + m_size; }
 
  RAJA_HOST_DEVICE Index_type size() const { return m_size; }
 
  RAJA_HOST_DEVICE IndexOwnership getIndexOwnership() const { return m_owned; }
 
 
 
  RAJA_HOST_DEVICE bool indicesEqual(const value_type* container,
                                     Index_type len) const
  {
    if (container == m_data) return len == m_size;
    if (len != m_size || container == nullptr || m_data == nullptr)
      return false;
    for (Index_type i = 0; i < m_size; ++i)
      if (m_data[i] != container[i]) return false;
    return true;
  }
 
  RAJA_HOST_DEVICE bool operator==(const TypedListSegment& other) const
  {
    return (indicesEqual(other.m_data, other.m_size));
  }
 
  RAJA_HOST_DEVICE bool operator!=(const TypedListSegment& other) const
  {
    return (!(*this == other));
  }
 
 
  RAJA_HOST_DEVICE void swap(TypedListSegment& other)
  {
    camp::safe_swap(m_resource, other.m_resource);
    camp::safe_swap(m_data, other.m_data);
    camp::safe_swap(m_size, other.m_size);
    camp::safe_swap(m_owned, other.m_owned);
  }
 
private:
  //
  // Initialize segment data based on whether object owns the index data.
  //
  void initIndexData(const value_type* container,
                     Index_type len,
                     camp::resources::Resource resource_,
                     IndexOwnership container_own)
  {
 
    // empty list segment
    if (len <= 0 || container == nullptr)
    {
      m_data  = nullptr;
      m_size  = 0;
      m_owned = Unowned;
      return;
    }
 
    // some non-zero size -- initialize accordingly
    m_size  = len;
    m_owned = container_own;
    if (m_owned == Owned)
    {
 
      m_resource = new camp::resources::Resource(resource_);
 
      camp::resources::Resource host_res {camp::resources::Host::get_default()};
 
      value_type* tmp = host_res.allocate<value_type>(m_size);
 
      for (Index_type i = 0; i < m_size; ++i)
      {
        tmp[i] = container[i];
      }
 
      m_data = m_resource->allocate<value_type>(m_size);
      m_resource->memcpy(m_data, tmp, sizeof(value_type) * m_size);
      m_resource->wait();
 
      host_res.deallocate(tmp);
 
      return;
    }
 
    // list segment accesses container data directly.
    // Uh-oh. Using evil const_cast....
    m_data = const_cast<value_type*>(container);
  }
 
  // Copy of camp resource passed to ctor
  camp::resources::Resource* m_resource;
 
  // Ownership flag to guide data copying/management
  IndexOwnership m_owned;
 
  // Buffer storage for segment index data
  value_type* RAJA_RESTRICT m_data;
 
  // Size of list segment
  Index_type m_size;
};
 
using ListSegment = TypedListSegment<Index_type>;
 
}  // namespace RAJA
 
namespace std
{
 
template<typename StorageT>
RAJA_INLINE void swap(RAJA::TypedListSegment<StorageT>& a,
                      RAJA::TypedListSegment<StorageT>& b)
{
  a.swap(b);
}
}  // namespace std
 
#endif  // closing endif for header file include guard