AtomicArrayExecutionObject.h

Go to the documentation of this file.

//============================================================================
//  The contents of this file are covered by the Viskores license. See
//  LICENSE.txt for details.
//
//  By contributing to this file, all contributors agree to the Developer
//  Certificate of Origin Version 1.1 (DCO 1.1) as stated in DCO.txt.
//============================================================================
 
//============================================================================
//  Copyright (c) Kitware, Inc.
//  All rights reserved.
//  See LICENSE.txt for details.
//
//  This software is distributed WITHOUT ANY WARRANTY; without even
//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
//  PURPOSE.  See the above copyright notice for more information.
//============================================================================
#ifndef viskores_exec_AtomicArrayExecutionObject_h
#define viskores_exec_AtomicArrayExecutionObject_h
 
#include <viskores/Atomic.h>
#include <viskores/List.h>
#include <viskores/cont/ArrayHandle.h>
#include <viskores/cont/DeviceAdapter.h>
 
#include <type_traits>
 
namespace viskores
{
namespace exec
{
 
namespace detail
{
// Clang-7 as host compiler under nvcc returns types from std::make_unsigned
// that are not compatible with the viskores::Atomic API, so we define our own
// mapping. This must exist for every entry in viskores::cont::AtomicArrayTypeList.
template <typename>
struct MakeUnsigned;
template <>
struct MakeUnsigned<viskores::UInt32>
{
  using type = viskores::UInt32;
};
template <>
struct MakeUnsigned<viskores::Int32>
{
  using type = viskores::UInt32;
};
template <>
struct MakeUnsigned<viskores::UInt64>
{
  using type = viskores::UInt64;
};
template <>
struct MakeUnsigned<viskores::Int64>
{
  using type = viskores::UInt64;
};
template <>
struct MakeUnsigned<viskores::Float32>
{
  using type = viskores::UInt32;
};
template <>
struct MakeUnsigned<viskores::Float64>
{
  using type = viskores::UInt64;
};
 
template <typename T>
struct ArithType
{
  using type = typename MakeUnsigned<T>::type;
};
template <>
struct ArithType<viskores::Float32>
{
  using type = viskores::Float32;
};
template <>
struct ArithType<viskores::Float64>
{
  using type = viskores::Float64;
};
}
 
template <typename T>
class AtomicArrayExecutionObject
{
  // Checks if PortalType has a GetIteratorBegin() method that returns a
  // pointer.
  template <typename PortalType,
            typename PointerType = decltype(std::declval<PortalType>().GetIteratorBegin())>
  struct HasPointerAccess : public std::is_pointer<PointerType>
  {
  };
 
public:
  using ValueType = T;
 
  AtomicArrayExecutionObject() = default;
 
  VISKORES_CONT AtomicArrayExecutionObject(viskores::cont::ArrayHandle<T> handle,
                                           viskores::cont::DeviceAdapterId device,
                                           viskores::cont::Token& token)
    : Data{ handle.PrepareForInPlace(device, token).GetIteratorBegin() }
    , NumberOfValues{ handle.GetNumberOfValues() }
  {
    using PortalType = decltype(handle.PrepareForInPlace(device, token));
    VISKORES_STATIC_ASSERT_MSG(HasPointerAccess<PortalType>::value,
                               "Source portal must return a pointer from "
                               "GetIteratorBegin().");
  }
 
  VISKORES_SUPPRESS_EXEC_WARNINGS
  VISKORES_EXEC
  viskores::Id GetNumberOfValues() const { return this->NumberOfValues; }
 
  VISKORES_SUPPRESS_EXEC_WARNINGS
  VISKORES_EXEC
  ValueType Get(viskores::Id index,
                viskores::MemoryOrder order = viskores::MemoryOrder::Acquire) const
  {
    // We only support 32/64 bit signed/unsigned ints, and viskores::Atomic
    // currently only provides API for unsigned types.
    // We'll cast the signed types to unsigned to work around this.
    using APIType = typename detail::MakeUnsigned<ValueType>::type;
 
    return static_cast<T>(
      viskores::AtomicLoad(reinterpret_cast<APIType*>(this->Data + index), order));
  }
 
  VISKORES_SUPPRESS_EXEC_WARNINGS
  VISKORES_EXEC
  ValueType Add(viskores::Id index,
                const ValueType& value,
                viskores::MemoryOrder order = viskores::MemoryOrder::SequentiallyConsistent) const
  {
    // We only support 32/64 bit signed/unsigned ints, and viskores::Atomic
    // currently only provides API for unsigned types.
    // We'll cast the signed types to unsigned to work around this.
    // This is safe, since the only difference between signed/unsigned types
    // is how overflow works, and signed overflow is already undefined. We also
    // document that overflow is undefined for this operation.
    using APIType = typename detail::ArithType<ValueType>::type;
 
    return static_cast<T>(viskores::AtomicAdd(
      reinterpret_cast<APIType*>(this->Data + index), static_cast<APIType>(value), order));
  }
 
  VISKORES_SUPPRESS_EXEC_WARNINGS
  VISKORES_EXEC
  void Set(viskores::Id index,
           const ValueType& value,
           viskores::MemoryOrder order = viskores::MemoryOrder::Release) const
  {
    // We only support 32/64 bit signed/unsigned ints, and viskores::Atomic
    // currently only provides API for unsigned types.
    // We'll cast the signed types to unsigned to work around this.
    // This is safe, since the only difference between signed/unsigned types
    // is how overflow works, and signed overflow is already undefined. We also
    // document that overflow is undefined for this operation.
    using APIType = typename detail::MakeUnsigned<ValueType>::type;
 
    viskores::AtomicStore(
      reinterpret_cast<APIType*>(this->Data + index), static_cast<APIType>(value), order);
  }
 
  VISKORES_SUPPRESS_EXEC_WARNINGS
  VISKORES_EXEC
  bool CompareExchange(
    viskores::Id index,
    ValueType* oldValue,
    const ValueType& newValue,
    viskores::MemoryOrder order = viskores::MemoryOrder::SequentiallyConsistent) const
  {
    // We only support 32/64 bit signed/unsigned ints, and viskores::Atomic
    // currently only provides API for unsigned types.
    // We'll cast the signed types to unsigned to work around this.
    // This is safe, since the only difference between signed/unsigned types
    // is how overflow works, and signed overflow is already undefined.
    using APIType = typename detail::MakeUnsigned<ValueType>::type;
 
    return viskores::AtomicCompareExchange(reinterpret_cast<APIType*>(this->Data + index),
                                           reinterpret_cast<APIType*>(oldValue),
                                           static_cast<APIType>(newValue),
                                           order);
  }
 
private:
  ValueType* Data{ nullptr };
  viskores::Id NumberOfValues{ 0 };
};
}
} // namespace viskores::exec
 
#endif //viskores_exec_AtomicArrayExecutionObject_h