2019-09-06 22:24:27 +00:00
|
|
|
//============================================================================
|
|
|
|
// 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 vtk_m_ArrayHandleDecorator_h
|
|
|
|
#define vtk_m_ArrayHandleDecorator_h
|
|
|
|
|
|
|
|
#include <vtkm/cont/ArrayHandle.h>
|
2019-12-20 22:03:36 +00:00
|
|
|
#include <vtkm/cont/ErrorBadType.h>
|
2019-09-06 22:24:27 +00:00
|
|
|
#include <vtkm/cont/Storage.h>
|
|
|
|
|
2022-02-09 19:56:46 +00:00
|
|
|
#include <vtkm/List.h>
|
2019-09-06 22:24:27 +00:00
|
|
|
#include <vtkm/StaticAssert.h>
|
2020-02-25 22:11:10 +00:00
|
|
|
#include <vtkm/Tuple.h>
|
2019-09-06 22:24:27 +00:00
|
|
|
#include <vtkm/VecTraits.h>
|
|
|
|
|
|
|
|
#include <vtkm/internal/ArrayPortalHelpers.h>
|
|
|
|
|
2020-02-25 22:11:10 +00:00
|
|
|
#include <vtkmstd/integer_sequence.h>
|
2019-09-18 18:16:42 +00:00
|
|
|
|
2023-06-02 12:23:03 +00:00
|
|
|
#include <array>
|
2022-06-28 20:26:38 +00:00
|
|
|
#include <numeric>
|
2019-09-06 22:24:27 +00:00
|
|
|
#include <type_traits>
|
|
|
|
#include <utility>
|
|
|
|
|
|
|
|
namespace vtkm
|
|
|
|
{
|
|
|
|
namespace internal
|
|
|
|
{
|
|
|
|
|
|
|
|
namespace decor
|
|
|
|
{
|
|
|
|
|
|
|
|
// Generic InverseFunctor implementation that does nothing.
|
|
|
|
struct NoOpInverseFunctor
|
|
|
|
{
|
|
|
|
NoOpInverseFunctor() = default;
|
|
|
|
template <typename... Ts>
|
|
|
|
VTKM_EXEC_CONT NoOpInverseFunctor(Ts...)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
template <typename VT>
|
|
|
|
VTKM_EXEC_CONT void operator()(vtkm::Id, VT) const
|
|
|
|
{
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
} // namespace decor
|
|
|
|
|
|
|
|
// The portal for ArrayHandleDecorator. Get calls FunctorType::operator(), and
|
|
|
|
// Set calls InverseFunctorType::operator(), but only if the DecoratorImpl
|
|
|
|
// provides an inverse.
|
|
|
|
template <typename ValueType_, typename FunctorType_, typename InverseFunctorType_>
|
|
|
|
class VTKM_ALWAYS_EXPORT ArrayPortalDecorator
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
using ValueType = ValueType_;
|
|
|
|
using FunctorType = FunctorType_;
|
|
|
|
using InverseFunctorType = InverseFunctorType_;
|
|
|
|
using ReadOnly = std::is_same<InverseFunctorType, decor::NoOpInverseFunctor>;
|
|
|
|
|
|
|
|
VTKM_EXEC_CONT
|
|
|
|
ArrayPortalDecorator() {}
|
|
|
|
|
|
|
|
VTKM_CONT
|
|
|
|
ArrayPortalDecorator(FunctorType func, InverseFunctorType iFunc, vtkm::Id numValues)
|
2019-09-18 18:16:42 +00:00
|
|
|
: Functor(func)
|
|
|
|
, InverseFunctor(iFunc)
|
|
|
|
, NumberOfValues(numValues)
|
2019-09-06 22:24:27 +00:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
VTKM_EXEC_CONT
|
|
|
|
vtkm::Id GetNumberOfValues() const { return this->NumberOfValues; }
|
|
|
|
|
|
|
|
VTKM_EXEC_CONT
|
|
|
|
ValueType Get(vtkm::Id index) const { return this->Functor(index); }
|
|
|
|
|
|
|
|
template <typename ReadOnly_ = ReadOnly,
|
|
|
|
typename = typename std::enable_if<!ReadOnly_::value>::type>
|
2019-09-13 14:22:30 +00:00
|
|
|
VTKM_EXEC_CONT void Set(vtkm::Id index, const ValueType& value) const
|
2019-09-06 22:24:27 +00:00
|
|
|
{
|
|
|
|
this->InverseFunctor(index, value);
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
FunctorType Functor;
|
|
|
|
InverseFunctorType InverseFunctor;
|
|
|
|
vtkm::Id NumberOfValues;
|
|
|
|
};
|
2020-11-19 19:16:36 +00:00
|
|
|
}
|
|
|
|
} // namespace vtkm::internal
|
|
|
|
|
|
|
|
namespace vtkm
|
|
|
|
{
|
|
|
|
namespace cont
|
|
|
|
{
|
|
|
|
|
|
|
|
namespace internal
|
|
|
|
{
|
2019-09-06 22:24:27 +00:00
|
|
|
|
|
|
|
namespace decor
|
|
|
|
{
|
|
|
|
|
|
|
|
// Ensures that all types in variadic container ArrayHandleList are subclasses
|
|
|
|
// of ArrayHandleBase.
|
|
|
|
template <typename ArrayHandleList>
|
2022-03-08 16:24:38 +00:00
|
|
|
using AllAreArrayHandles = vtkm::ListAll<ArrayHandleList, vtkm::cont::internal::ArrayHandleCheck>;
|
2019-09-06 22:24:27 +00:00
|
|
|
|
|
|
|
namespace detail
|
|
|
|
{
|
|
|
|
|
|
|
|
// Tests whether DecoratorImplT has a CreateInverseFunctor(Portals...) method.
|
|
|
|
template <typename DecoratorImplT, typename PortalList>
|
|
|
|
struct IsFunctorInvertibleImpl;
|
|
|
|
|
|
|
|
template <typename DecoratorImplT, template <typename...> class List, typename... PortalTs>
|
|
|
|
struct IsFunctorInvertibleImpl<DecoratorImplT, List<PortalTs...>>
|
|
|
|
{
|
|
|
|
private:
|
|
|
|
template <
|
|
|
|
typename T,
|
2019-12-20 21:17:30 +00:00
|
|
|
typename U = decltype(std::declval<T>().CreateInverseFunctor(std::declval<PortalTs&&>()...))>
|
2019-09-06 22:24:27 +00:00
|
|
|
static std::true_type InverseExistsTest(int);
|
|
|
|
|
|
|
|
template <typename T>
|
|
|
|
static std::false_type InverseExistsTest(...);
|
|
|
|
|
|
|
|
public:
|
|
|
|
using type = decltype(InverseExistsTest<DecoratorImplT>(0));
|
|
|
|
};
|
|
|
|
|
2019-12-20 22:03:36 +00:00
|
|
|
// Tests whether DecoratorImplT has an AllocateSourceArrays(size, Arrays...) method.
|
|
|
|
template <typename DecoratorImplT, typename ArrayList>
|
|
|
|
struct IsDecoratorAllocatableImpl;
|
|
|
|
|
|
|
|
template <typename DecoratorImplT, template <typename...> class List, typename... ArrayTs>
|
|
|
|
struct IsDecoratorAllocatableImpl<DecoratorImplT, List<ArrayTs...>>
|
|
|
|
{
|
|
|
|
private:
|
|
|
|
template <
|
|
|
|
typename T,
|
2020-11-19 19:16:36 +00:00
|
|
|
typename U = decltype(std::declval<T>().AllocateSourceArrays(0,
|
|
|
|
vtkm::CopyFlag::Off,
|
|
|
|
std::declval<vtkm::cont::Token&>(),
|
|
|
|
std::declval<ArrayTs&>()...))>
|
2019-12-20 22:03:36 +00:00
|
|
|
static std::true_type Exists(int);
|
|
|
|
template <typename T>
|
|
|
|
static std::false_type Exists(...);
|
|
|
|
|
|
|
|
public:
|
|
|
|
using type = decltype(Exists<DecoratorImplT>(0));
|
|
|
|
};
|
|
|
|
|
2019-09-06 22:24:27 +00:00
|
|
|
// Deduces the type returned by DecoratorImplT::CreateFunctor when given
|
|
|
|
// the specified portals.
|
|
|
|
template <typename DecoratorImplT, typename PortalList>
|
|
|
|
struct GetFunctorTypeImpl;
|
|
|
|
|
|
|
|
template <typename DecoratorImplT, template <typename...> class List, typename... PortalTs>
|
|
|
|
struct GetFunctorTypeImpl<DecoratorImplT, List<PortalTs...>>
|
|
|
|
{
|
2019-12-20 21:17:30 +00:00
|
|
|
using type =
|
|
|
|
decltype(std::declval<DecoratorImplT>().CreateFunctor(std::declval<PortalTs&&>()...));
|
2019-09-06 22:24:27 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
// Deduces the type returned by DecoratorImplT::CreateInverseFunctor when given
|
|
|
|
// the specified portals. If DecoratorImplT doesn't have a CreateInverseFunctor
|
|
|
|
// method, a NoOp functor will be used instead.
|
|
|
|
template <typename CanWrite, typename DecoratorImplT, typename PortalList>
|
|
|
|
struct GetInverseFunctorTypeImpl;
|
|
|
|
|
|
|
|
template <typename DecoratorImplT, template <typename...> class List, typename... PortalTs>
|
|
|
|
struct GetInverseFunctorTypeImpl<std::true_type, DecoratorImplT, List<PortalTs...>>
|
|
|
|
{
|
|
|
|
using type =
|
2019-12-20 21:17:30 +00:00
|
|
|
decltype(std::declval<DecoratorImplT>().CreateInverseFunctor(std::declval<PortalTs&&>()...));
|
2019-09-06 22:24:27 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
template <typename DecoratorImplT, typename PortalList>
|
|
|
|
struct GetInverseFunctorTypeImpl<std::false_type, DecoratorImplT, PortalList>
|
|
|
|
{
|
2020-11-19 19:16:36 +00:00
|
|
|
using type = vtkm::internal::decor::NoOpInverseFunctor;
|
2019-09-06 22:24:27 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
// Get appropriate portals from a source array.
|
|
|
|
// See note below about using non-writable portals in invertible functors.
|
|
|
|
// We need to sub in const portals when writable ones don't exist.
|
|
|
|
template <typename ArrayT>
|
2020-11-19 19:16:36 +00:00
|
|
|
typename std::decay<ArrayT>::type::WritePortalType GetWritePortalImpl(
|
|
|
|
std::true_type,
|
|
|
|
ArrayT&& array,
|
|
|
|
vtkm::cont::DeviceAdapterId device,
|
|
|
|
vtkm::cont::Token& token)
|
2019-09-06 22:24:27 +00:00
|
|
|
{
|
2020-11-19 19:16:36 +00:00
|
|
|
return ArrayT::StorageType::CreateWritePortal(array.GetBuffers(), device, token);
|
2019-09-06 22:24:27 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
template <typename ArrayT>
|
2020-11-19 19:16:36 +00:00
|
|
|
typename std::decay<ArrayT>::type::ReadPortalType GetWritePortalImpl(
|
|
|
|
std::false_type,
|
|
|
|
ArrayT&& array,
|
|
|
|
vtkm::cont::DeviceAdapterId device,
|
|
|
|
vtkm::cont::Token& token)
|
2019-09-06 22:24:27 +00:00
|
|
|
{
|
2020-11-19 19:16:36 +00:00
|
|
|
return ArrayT::StorageType::CreateReadPortal(array.GetBuffers(), device, token);
|
2019-09-06 22:24:27 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
} // namespace detail
|
|
|
|
|
|
|
|
// Get portal types:
|
|
|
|
// We allow writing to an AHDecorator if *any* of the ArrayHandles are writable.
|
|
|
|
// This means we have to avoid calling PrepareForOutput, etc on non-writable
|
|
|
|
// array handles, since these may throw. On non-writable handles, use the
|
|
|
|
// const array handles so we can at least read from them in the inverse
|
|
|
|
// functors.
|
2022-02-09 19:56:46 +00:00
|
|
|
template <typename ArrayT>
|
|
|
|
using GetWritePortalType = std::conditional_t<
|
|
|
|
vtkm::internal::PortalSupportsSets<typename std::decay<ArrayT>::type::WritePortalType>::value,
|
|
|
|
typename std::decay<ArrayT>::type::WritePortalType,
|
|
|
|
typename std::decay<ArrayT>::type::ReadPortalType>;
|
2019-09-06 22:24:27 +00:00
|
|
|
|
|
|
|
template <typename ArrayT>
|
2020-11-19 19:16:36 +00:00
|
|
|
using GetReadPortalType = typename std::decay<ArrayT>::type::ReadPortalType;
|
2019-09-06 22:24:27 +00:00
|
|
|
|
|
|
|
// Get portal objects:
|
|
|
|
// See note above -- we swap in const portals sometimes.
|
|
|
|
template <typename ArrayT>
|
2020-11-19 19:16:36 +00:00
|
|
|
GetWritePortalType<typename std::decay<ArrayT>::type>
|
|
|
|
WritePortal(ArrayT&& array, vtkm::cont::DeviceAdapterId device, vtkm::cont::Token& token)
|
2019-09-06 22:24:27 +00:00
|
|
|
{
|
2020-11-19 19:16:36 +00:00
|
|
|
return detail::GetWritePortalImpl(
|
|
|
|
IsWritableArrayHandle<ArrayT>{}, std::forward<ArrayT>(array), device, token);
|
2019-09-06 22:24:27 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
template <typename ArrayT>
|
2020-11-19 19:16:36 +00:00
|
|
|
GetReadPortalType<typename std::decay<ArrayT>::type> ReadPortal(const ArrayT& array,
|
|
|
|
vtkm::cont::DeviceAdapterId device,
|
|
|
|
vtkm::cont::Token& token)
|
2019-09-06 22:24:27 +00:00
|
|
|
{
|
2020-11-19 19:16:36 +00:00
|
|
|
return ArrayT::StorageType::CreateReadPortal(array.GetBuffers(), device, token);
|
2019-09-06 22:24:27 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// Equivalent to std::true_type if *any* portal in PortalList can be written to.
|
|
|
|
// If all are read-only, std::false_type is used instead.
|
|
|
|
template <typename PortalList>
|
2022-03-08 16:24:38 +00:00
|
|
|
using AnyPortalIsWritable = vtkm::ListAny<PortalList, vtkm::internal::PortalSupportsSets>;
|
2019-09-06 22:24:27 +00:00
|
|
|
|
|
|
|
// Set to std::true_type if DecoratorImplT::CreateInverseFunctor can be called
|
|
|
|
// with the supplied portals, or std::false_type otherwise.
|
|
|
|
template <typename DecoratorImplT, typename PortalList>
|
|
|
|
using IsFunctorInvertible =
|
|
|
|
typename detail::IsFunctorInvertibleImpl<DecoratorImplT, PortalList>::type;
|
|
|
|
|
2019-12-20 22:03:36 +00:00
|
|
|
// Set to std::true_type if DecoratorImplT::AllocateSourceArrays can be called
|
|
|
|
// with the supplied arrays, or std::false_type otherwise.
|
|
|
|
template <typename DecoratorImplT, typename ArrayList>
|
|
|
|
using IsDecoratorAllocatable =
|
|
|
|
typename detail::IsDecoratorAllocatableImpl<DecoratorImplT, ArrayList>::type;
|
|
|
|
|
2019-09-06 22:24:27 +00:00
|
|
|
// std::true_type/std::false_type depending on whether the decorator impl has a
|
|
|
|
// CreateInversePortal method AND any of the arrays are writable.
|
|
|
|
template <typename DecoratorImplT, typename PortalList>
|
2022-02-09 19:56:46 +00:00
|
|
|
using CanWriteToFunctor = vtkm::internal::meta::And<IsFunctorInvertible<DecoratorImplT, PortalList>,
|
|
|
|
AnyPortalIsWritable<PortalList>>;
|
2019-09-06 22:24:27 +00:00
|
|
|
|
|
|
|
// The FunctorType for the provided implementation and portal types.
|
|
|
|
template <typename DecoratorImplT, typename PortalList>
|
|
|
|
using GetFunctorType = typename detail::GetFunctorTypeImpl<DecoratorImplT, PortalList>::type;
|
|
|
|
|
|
|
|
// The InverseFunctorType for the provided implementation and portal types.
|
|
|
|
// Will detect when inversion is not possible and return a NoOp functor instead.
|
|
|
|
template <typename DecoratorImplT, typename PortalList>
|
|
|
|
using GetInverseFunctorType =
|
|
|
|
typename detail::GetInverseFunctorTypeImpl<CanWriteToFunctor<DecoratorImplT, PortalList>,
|
|
|
|
DecoratorImplT,
|
|
|
|
PortalList>::type;
|
|
|
|
|
|
|
|
// Convert a sequence of array handle types to a list of portals:
|
|
|
|
|
|
|
|
// Some notes on this implementation:
|
2022-02-09 19:56:46 +00:00
|
|
|
// - A more straightforward way to implement these to types would be to take
|
|
|
|
// a simple template that takes a vtkm::List of array types and convert
|
|
|
|
// that with vtkm::ListTransform<ArrayList, GetWritePortalType>. However,
|
|
|
|
// this causes a strange compiler error in VS 2017 when evaluating the
|
|
|
|
// `ValueType` in `DecoratorStorageTraits`. (It does not recognize the
|
|
|
|
// decorator impl functor as a function taking one argument, even when it
|
|
|
|
// effectively is.) A previous similar implementation caused an ICE in
|
|
|
|
// VS 2015 (although that compiler is no longer supported anyway).
|
|
|
|
// - The same problem happens with VS 2017 if you just try to create a list
|
|
|
|
// with vtkm::List<GetWritePortalType<ArrayTs>...>.
|
2019-09-06 22:24:27 +00:00
|
|
|
// - So we jump through some decltype/declval hoops here to get this to work:
|
|
|
|
template <typename... ArrayTs>
|
2020-11-19 19:16:36 +00:00
|
|
|
using GetReadPortalList =
|
2022-02-09 19:56:46 +00:00
|
|
|
vtkm::List<decltype((ReadPortal(std::declval<ArrayTs&>(),
|
|
|
|
std::declval<vtkm::cont::DeviceAdapterId>(),
|
|
|
|
std::declval<vtkm::cont::Token&>())))...>;
|
2019-09-06 22:24:27 +00:00
|
|
|
|
|
|
|
template <typename... ArrayTs>
|
2020-11-19 19:16:36 +00:00
|
|
|
using GetWritePortalList =
|
2022-02-09 19:56:46 +00:00
|
|
|
vtkm::List<decltype((WritePortal(std::declval<ArrayTs&>(),
|
|
|
|
std::declval<vtkm::cont::DeviceAdapterId>(),
|
|
|
|
std::declval<vtkm::cont::Token&>())))...>;
|
2019-09-06 22:24:27 +00:00
|
|
|
|
2022-06-28 20:26:38 +00:00
|
|
|
template <typename DecoratorImplT, std::size_t NumArrays>
|
2020-11-19 19:16:36 +00:00
|
|
|
struct DecoratorMetaData
|
|
|
|
{
|
|
|
|
DecoratorImplT Implementation;
|
|
|
|
vtkm::Id NumberOfValues = 0;
|
2022-06-28 20:26:38 +00:00
|
|
|
std::array<std::size_t, NumArrays + 1> BufferOffsets;
|
2020-11-19 19:16:36 +00:00
|
|
|
|
2022-06-28 20:26:38 +00:00
|
|
|
template <typename... ArrayTs>
|
|
|
|
DecoratorMetaData(const DecoratorImplT& implementation,
|
|
|
|
vtkm::Id numValues,
|
|
|
|
const ArrayTs... arrays)
|
2020-11-19 19:16:36 +00:00
|
|
|
: Implementation(implementation)
|
|
|
|
, NumberOfValues(numValues)
|
|
|
|
{
|
2022-06-28 20:26:38 +00:00
|
|
|
auto numBuffers = { std::size_t{ 1 }, arrays.GetBuffers().size()... };
|
|
|
|
std::partial_sum(numBuffers.begin(), numBuffers.end(), this->BufferOffsets.begin());
|
2020-11-19 19:16:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
DecoratorMetaData() = default;
|
|
|
|
};
|
2019-09-06 22:24:27 +00:00
|
|
|
|
|
|
|
template <typename DecoratorImplT, typename... ArrayTs>
|
|
|
|
struct DecoratorStorageTraits
|
|
|
|
{
|
2022-02-09 19:56:46 +00:00
|
|
|
using ArrayList = vtkm::List<ArrayTs...>;
|
2019-09-06 22:24:27 +00:00
|
|
|
|
|
|
|
VTKM_STATIC_ASSERT_MSG(sizeof...(ArrayTs) > 0,
|
|
|
|
"Must specify at least one source array handle for "
|
|
|
|
"ArrayHandleDecorator. Consider using "
|
|
|
|
"ArrayHandleImplicit instead.");
|
|
|
|
|
|
|
|
// Need to check this here, since this traits struct is used in the
|
|
|
|
// ArrayHandleDecorator superclass definition before any other
|
|
|
|
// static_asserts could be used.
|
|
|
|
VTKM_STATIC_ASSERT_MSG(decor::AllAreArrayHandles<ArrayList>::value,
|
|
|
|
"Trailing template parameters for "
|
|
|
|
"ArrayHandleDecorator must be a list of ArrayHandle "
|
|
|
|
"types.");
|
|
|
|
|
2020-02-25 22:11:10 +00:00
|
|
|
using ArrayTupleType = vtkm::Tuple<ArrayTs...>;
|
2019-09-06 22:24:27 +00:00
|
|
|
|
2020-02-25 22:11:10 +00:00
|
|
|
// size_t integral constants that index ArrayTs:
|
|
|
|
using IndexList = vtkmstd::make_index_sequence<sizeof...(ArrayTs)>;
|
2019-09-06 22:24:27 +00:00
|
|
|
|
2022-06-28 20:26:38 +00:00
|
|
|
using MetaData = DecoratorMetaData<DecoratorImplT, sizeof...(ArrayTs)>;
|
|
|
|
|
|
|
|
static MetaData& GetMetaData(const std::vector<vtkm::cont::internal::Buffer>& buffers)
|
2020-11-19 19:16:36 +00:00
|
|
|
{
|
2022-06-28 20:26:38 +00:00
|
|
|
return buffers[0].GetMetaData<MetaData>();
|
2020-11-19 19:16:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// Converts a buffers array to the ArrayHandle at the given index.
|
|
|
|
template <vtkm::IdComponent I>
|
|
|
|
static vtkm::TupleElement<I, ArrayTupleType> BuffersToArray(
|
2022-06-28 20:26:38 +00:00
|
|
|
const std::vector<vtkm::cont::internal::Buffer>& buffers)
|
2020-11-19 19:16:36 +00:00
|
|
|
{
|
2022-06-28 20:26:38 +00:00
|
|
|
const MetaData& metaData = GetMetaData(buffers);
|
|
|
|
std::vector<vtkm::cont::internal::Buffer> subBuffers(
|
|
|
|
buffers.begin() + metaData.BufferOffsets[I], buffers.begin() + metaData.BufferOffsets[I + 1]);
|
|
|
|
return vtkm::TupleElement<I, ArrayTupleType>(std::move(subBuffers));
|
2020-11-19 19:16:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// true_type/false_type depending on whether the decorator supports Allocate:
|
2019-12-20 22:03:36 +00:00
|
|
|
using IsAllocatable = IsDecoratorAllocatable<DecoratorImplT, ArrayList>;
|
|
|
|
|
2019-09-06 22:24:27 +00:00
|
|
|
// Portal lists:
|
|
|
|
// NOTE we have to pass the parameter pack here instead of using ArrayList
|
2022-02-09 19:56:46 +00:00
|
|
|
// with vtkm::ListTransform, since that's causing problems with VS 2017:
|
2020-11-19 19:16:36 +00:00
|
|
|
using WritePortalList = GetWritePortalList<ArrayTs...>;
|
|
|
|
using ReadPortalList = GetReadPortalList<ArrayTs...>;
|
2019-09-06 22:24:27 +00:00
|
|
|
|
|
|
|
// Functors:
|
2020-11-19 19:16:36 +00:00
|
|
|
using WriteFunctorType = GetFunctorType<DecoratorImplT, WritePortalList>;
|
|
|
|
using ReadFunctorType = GetFunctorType<DecoratorImplT, ReadPortalList>;
|
2019-09-06 22:24:27 +00:00
|
|
|
|
|
|
|
// Inverse functors:
|
2020-11-19 19:16:36 +00:00
|
|
|
using InverseWriteFunctorType = GetInverseFunctorType<DecoratorImplT, WritePortalList>;
|
2019-09-06 22:24:27 +00:00
|
|
|
|
2020-11-19 19:16:36 +00:00
|
|
|
using InverseReadFunctorType = vtkm::internal::decor::NoOpInverseFunctor;
|
2019-09-06 22:24:27 +00:00
|
|
|
|
|
|
|
// Misc:
|
|
|
|
// ValueType is derived from DecoratorImplT::CreateFunctor(...)'s operator().
|
2020-11-19 19:16:36 +00:00
|
|
|
using ValueType = decltype(std::declval<WriteFunctorType>()(0));
|
2019-09-06 22:24:27 +00:00
|
|
|
|
|
|
|
// Decorator portals:
|
2020-11-19 19:16:36 +00:00
|
|
|
using WritePortalType =
|
|
|
|
vtkm::internal::ArrayPortalDecorator<ValueType, WriteFunctorType, InverseWriteFunctorType>;
|
2019-09-06 22:24:27 +00:00
|
|
|
|
2020-11-19 19:16:36 +00:00
|
|
|
using ReadPortalType =
|
|
|
|
vtkm::internal::ArrayPortalDecorator<ValueType, ReadFunctorType, InverseReadFunctorType>;
|
2019-09-06 22:24:27 +00:00
|
|
|
|
|
|
|
// helper for constructing portals with the appropriate functors. This is
|
|
|
|
// where we decide whether or not to call `CreateInverseFunctor` on the
|
|
|
|
// implementation class.
|
|
|
|
// Do not use these directly, they are helpers for the MakePortal[...]
|
|
|
|
// methods below.
|
|
|
|
template <typename DecoratorPortalType, typename... PortalTs>
|
|
|
|
VTKM_CONT static
|
|
|
|
typename std::enable_if<DecoratorPortalType::ReadOnly::value, DecoratorPortalType>::type
|
|
|
|
CreatePortalDecorator(vtkm::Id numVals, const DecoratorImplT& impl, PortalTs&&... portals)
|
|
|
|
{ // Portal is read only:
|
|
|
|
return { impl.CreateFunctor(std::forward<PortalTs>(portals)...),
|
|
|
|
typename DecoratorPortalType::InverseFunctorType{},
|
|
|
|
numVals };
|
|
|
|
}
|
|
|
|
|
|
|
|
template <typename DecoratorPortalType, typename... PortalTs>
|
|
|
|
VTKM_CONT static
|
|
|
|
typename std::enable_if<!DecoratorPortalType::ReadOnly::value, DecoratorPortalType>::type
|
|
|
|
CreatePortalDecorator(vtkm::Id numVals, const DecoratorImplT& impl, PortalTs... portals)
|
|
|
|
{ // Portal is read/write:
|
|
|
|
return { impl.CreateFunctor(portals...), impl.CreateInverseFunctor(portals...), numVals };
|
|
|
|
}
|
|
|
|
|
2019-12-20 22:03:36 +00:00
|
|
|
// Static dispatch for calling AllocateSourceArrays on supported implementations:
|
2020-08-17 14:18:24 +00:00
|
|
|
VTKM_CONT [[noreturn]] static void CallAllocate(std::false_type,
|
|
|
|
vtkm::Id,
|
2022-06-28 20:26:38 +00:00
|
|
|
const std::vector<vtkm::cont::internal::Buffer>&,
|
2020-11-19 19:16:36 +00:00
|
|
|
vtkm::CopyFlag,
|
|
|
|
vtkm::cont::Token&,
|
|
|
|
ArrayTs...)
|
2019-12-20 22:03:36 +00:00
|
|
|
{
|
|
|
|
throw vtkm::cont::ErrorBadType("Allocate not supported by this ArrayHandleDecorator.");
|
|
|
|
}
|
|
|
|
|
|
|
|
VTKM_CONT static void CallAllocate(std::true_type,
|
|
|
|
vtkm::Id newSize,
|
2022-06-28 20:26:38 +00:00
|
|
|
const std::vector<vtkm::cont::internal::Buffer>& buffers,
|
2020-11-19 19:16:36 +00:00
|
|
|
vtkm::CopyFlag preserve,
|
|
|
|
vtkm::cont::Token& token,
|
|
|
|
ArrayTs... arrays)
|
2019-12-20 22:03:36 +00:00
|
|
|
{
|
2020-11-19 19:16:36 +00:00
|
|
|
MetaData& metadata = GetMetaData(buffers);
|
|
|
|
metadata.Implementation.AllocateSourceArrays(newSize, preserve, token, arrays...);
|
|
|
|
metadata.NumberOfValues = newSize;
|
2019-12-20 22:03:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2019-09-06 22:24:27 +00:00
|
|
|
// Portal construction methods. These actually create portals.
|
2020-02-27 21:52:00 +00:00
|
|
|
template <std::size_t... Indices>
|
2022-06-28 20:26:38 +00:00
|
|
|
VTKM_CONT static WritePortalType CreateWritePortal(
|
|
|
|
const std::vector<vtkm::cont::internal::Buffer>& buffers,
|
|
|
|
vtkm::Id numValues,
|
|
|
|
vtkmstd::index_sequence<Indices...>,
|
|
|
|
vtkm::cont::DeviceAdapterId device,
|
|
|
|
vtkm::cont::Token& token)
|
2019-09-06 22:24:27 +00:00
|
|
|
{
|
2020-11-19 19:16:36 +00:00
|
|
|
return CreatePortalDecorator<WritePortalType>(
|
|
|
|
numValues,
|
|
|
|
GetMetaData(buffers).Implementation,
|
|
|
|
WritePortal(BuffersToArray<Indices>(buffers), device, token)...);
|
2019-09-06 22:24:27 +00:00
|
|
|
}
|
|
|
|
|
2020-02-27 21:52:00 +00:00
|
|
|
template <std::size_t... Indices>
|
2022-06-28 20:26:38 +00:00
|
|
|
VTKM_CONT static ReadPortalType CreateReadPortal(
|
|
|
|
const std::vector<vtkm::cont::internal::Buffer>& buffers,
|
|
|
|
vtkm::Id numValues,
|
|
|
|
vtkmstd::index_sequence<Indices...>,
|
|
|
|
vtkm::cont::DeviceAdapterId device,
|
|
|
|
vtkm::cont::Token& token)
|
2019-09-06 22:24:27 +00:00
|
|
|
{
|
2020-11-19 19:16:36 +00:00
|
|
|
return CreatePortalDecorator<ReadPortalType>(
|
|
|
|
numValues,
|
|
|
|
GetMetaData(buffers).Implementation,
|
|
|
|
ReadPortal(BuffersToArray<Indices>(buffers), device, token)...);
|
2019-09-18 18:16:42 +00:00
|
|
|
}
|
2019-12-20 22:03:36 +00:00
|
|
|
|
2020-02-27 21:52:00 +00:00
|
|
|
template <std::size_t... Indices>
|
2022-06-28 20:26:38 +00:00
|
|
|
VTKM_CONT static void AllocateSourceArrays(
|
|
|
|
vtkm::Id numValues,
|
|
|
|
const std::vector<vtkm::cont::internal::Buffer>& buffers,
|
|
|
|
vtkm::CopyFlag preserve,
|
|
|
|
vtkm::cont::Token& token,
|
|
|
|
vtkmstd::index_sequence<Indices...>)
|
2019-12-20 22:03:36 +00:00
|
|
|
{
|
2020-11-19 19:16:36 +00:00
|
|
|
CallAllocate(
|
|
|
|
IsAllocatable{}, numValues, buffers, preserve, token, BuffersToArray<Indices>(buffers)...);
|
2019-12-20 22:03:36 +00:00
|
|
|
}
|
2019-09-06 22:24:27 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
} // end namespace decor
|
|
|
|
|
|
|
|
template <typename DecoratorImplT, typename... ArrayTs>
|
|
|
|
struct VTKM_ALWAYS_EXPORT StorageTagDecorator
|
|
|
|
{
|
|
|
|
};
|
|
|
|
|
|
|
|
template <typename DecoratorImplT, typename... ArrayTs>
|
|
|
|
class Storage<typename decor::DecoratorStorageTraits<DecoratorImplT, ArrayTs...>::ValueType,
|
|
|
|
StorageTagDecorator<DecoratorImplT, ArrayTs...>>
|
|
|
|
{
|
|
|
|
using Traits = decor::DecoratorStorageTraits<DecoratorImplT, ArrayTs...>;
|
|
|
|
using IndexList = typename Traits::IndexList;
|
2020-11-19 19:16:36 +00:00
|
|
|
using MetaData = typename Traits::MetaData;
|
2019-09-06 22:24:27 +00:00
|
|
|
|
|
|
|
public:
|
2020-11-19 19:16:36 +00:00
|
|
|
using ReadPortalType = typename Traits::ReadPortalType;
|
|
|
|
using WritePortalType = typename Traits::WritePortalType;
|
2019-09-06 22:24:27 +00:00
|
|
|
|
2023-10-03 14:31:38 +00:00
|
|
|
private:
|
|
|
|
VTKM_CONT static vtkm::IdComponent GetNumberOfComponentsFlatImpl(vtkm::VecTraitsTagSizeStatic)
|
|
|
|
{
|
|
|
|
return vtkm::VecFlat<DecoratorImplT>::NUM_COMPONENTS;
|
|
|
|
}
|
|
|
|
|
|
|
|
VTKM_CONT static vtkm::IdComponent GetNumberOfComponentsFlatImpl(vtkm::VecTraitsTagSizeVariable)
|
|
|
|
{
|
|
|
|
// Currently only support getting the number of components for statically sized types.
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
public:
|
|
|
|
VTKM_CONT static vtkm::IdComponent GetNumberOfComponentsFlat(
|
|
|
|
const std::vector<vtkm::cont::internal::Buffer>&)
|
|
|
|
{
|
|
|
|
return GetNumberOfComponentsFlatImpl(typename vtkm::VecTraits<DecoratorImplT>::IsSizeStatic{});
|
|
|
|
}
|
|
|
|
|
2022-06-28 20:26:38 +00:00
|
|
|
VTKM_CONT static vtkm::Id GetNumberOfValues(
|
|
|
|
const std::vector<vtkm::cont::internal::Buffer>& buffers)
|
2019-09-06 22:24:27 +00:00
|
|
|
{
|
2020-11-19 19:16:36 +00:00
|
|
|
return Traits::GetMetaData(buffers).NumberOfValues;
|
2019-09-06 22:24:27 +00:00
|
|
|
}
|
|
|
|
|
2020-11-19 19:16:36 +00:00
|
|
|
VTKM_CONT static void ResizeBuffers(vtkm::Id numValues,
|
2022-06-28 20:26:38 +00:00
|
|
|
const std::vector<vtkm::cont::internal::Buffer>& buffers,
|
2020-11-19 19:16:36 +00:00
|
|
|
vtkm::CopyFlag preserve,
|
|
|
|
vtkm::cont::Token& token)
|
2019-09-06 22:24:27 +00:00
|
|
|
{
|
2020-11-19 19:16:36 +00:00
|
|
|
if (numValues != GetNumberOfValues(buffers))
|
|
|
|
{
|
|
|
|
Traits::AllocateSourceArrays(numValues, buffers, preserve, token, IndexList{});
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
// Do nothing. We have this condition to allow allocating the same size when the
|
|
|
|
// array cannot be resized.
|
|
|
|
}
|
2019-09-06 22:24:27 +00:00
|
|
|
}
|
|
|
|
|
2022-06-28 20:26:38 +00:00
|
|
|
VTKM_CONT static ReadPortalType CreateReadPortal(
|
|
|
|
const std::vector<vtkm::cont::internal::Buffer>& buffers,
|
|
|
|
vtkm::cont::DeviceAdapterId device,
|
|
|
|
vtkm::cont::Token& token)
|
2019-09-06 22:24:27 +00:00
|
|
|
{
|
2020-11-19 19:16:36 +00:00
|
|
|
return Traits::CreateReadPortal(
|
|
|
|
buffers, GetNumberOfValues(buffers), IndexList{}, device, token);
|
2019-09-06 22:24:27 +00:00
|
|
|
}
|
|
|
|
|
2022-06-28 20:26:38 +00:00
|
|
|
VTKM_CONT static WritePortalType CreateWritePortal(
|
|
|
|
const std::vector<vtkm::cont::internal::Buffer>& buffers,
|
|
|
|
vtkm::cont::DeviceAdapterId device,
|
|
|
|
vtkm::cont::Token& token)
|
2019-09-06 22:24:27 +00:00
|
|
|
{
|
2020-11-19 19:16:36 +00:00
|
|
|
return Traits::CreateWritePortal(
|
|
|
|
buffers, GetNumberOfValues(buffers), IndexList{}, device, token);
|
2019-09-06 22:24:27 +00:00
|
|
|
}
|
|
|
|
|
2020-11-19 19:16:36 +00:00
|
|
|
VTKM_CONT static std::vector<vtkm::cont::internal::Buffer>
|
|
|
|
CreateBuffers(const DecoratorImplT& implementation, vtkm::Id numValues, const ArrayTs&... arrays)
|
2019-09-06 22:24:27 +00:00
|
|
|
{
|
2022-06-28 20:26:38 +00:00
|
|
|
return vtkm::cont::internal::CreateBuffers(MetaData(implementation, numValues, arrays...),
|
|
|
|
arrays...);
|
|
|
|
}
|
|
|
|
|
|
|
|
VTKM_CONT static std::vector<vtkm::cont::internal::Buffer> CreateBuffers()
|
|
|
|
{
|
|
|
|
return CreateBuffers(DecoratorImplT{}, 0, ArrayTs{}...);
|
2019-09-06 22:24:27 +00:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
template <typename DecoratorImplT, typename... ArrayTs>
|
|
|
|
struct DecoratorHandleTraits
|
|
|
|
{
|
|
|
|
using StorageTraits = decor::DecoratorStorageTraits<DecoratorImplT, ArrayTs...>;
|
|
|
|
using ValueType = typename StorageTraits::ValueType;
|
|
|
|
using StorageTag = StorageTagDecorator<DecoratorImplT, ArrayTs...>;
|
|
|
|
using Superclass = vtkm::cont::ArrayHandle<ValueType, StorageTag>;
|
|
|
|
};
|
|
|
|
|
|
|
|
} // namespace internal
|
|
|
|
|
|
|
|
/// \brief A fancy ArrayHandle that can be used to modify the results from one
|
|
|
|
/// or more source ArrayHandle.
|
|
|
|
///
|
|
|
|
/// ArrayHandleDecorator is given a `DecoratorImplT` class and a list of one or
|
|
|
|
/// more source ArrayHandles. There are no restrictions on the size or type of
|
|
|
|
/// the source ArrayHandles.
|
|
|
|
///
|
|
|
|
/// The decorator implementation class is described below:
|
|
|
|
///
|
|
|
|
/// ```
|
|
|
|
/// struct ExampleDecoratorImplementation
|
|
|
|
/// {
|
|
|
|
///
|
|
|
|
/// // Takes one portal for each source array handle (only two shown).
|
|
|
|
/// // Returns a functor that defines:
|
|
|
|
/// //
|
2019-12-20 21:18:09 +00:00
|
|
|
/// // VTKM_EXEC_CONT ValueType operator()(vtkm::Id id) const;
|
2019-09-06 22:24:27 +00:00
|
|
|
/// //
|
|
|
|
/// // which takes an index and returns a value which should be produced by
|
|
|
|
/// // the source arrays somehow. This ValueType will be the ValueType of the
|
|
|
|
/// // ArrayHandleDecorator.
|
|
|
|
/// //
|
|
|
|
/// // Both SomeFunctor::operator() and CreateFunctor must be const.
|
|
|
|
/// //
|
|
|
|
/// template <typename Portal1Type, typename Portal2Type>
|
2019-12-20 21:18:09 +00:00
|
|
|
/// VTKM_CONT
|
2019-09-06 22:24:27 +00:00
|
|
|
/// SomeFunctor CreateFunctor(Portal1Type portal1, Portal2Type portal2) const;
|
|
|
|
///
|
|
|
|
/// // Takes one portal for each source array handle (only two shown).
|
|
|
|
/// // Returns a functor that defines:
|
|
|
|
/// //
|
2019-12-20 21:18:09 +00:00
|
|
|
/// // VTKM_EXEC_CONT void operator()(vtkm::Id id, ValueType val) const;
|
2019-09-06 22:24:27 +00:00
|
|
|
/// //
|
|
|
|
/// // which takes an index and a value, which should be used to modify one
|
|
|
|
/// // or more of the source arrays.
|
|
|
|
/// //
|
|
|
|
/// // CreateInverseFunctor is optional; if not provided, the
|
|
|
|
/// // ArrayHandleDecorator will be read-only. In addition, if all of the
|
|
|
|
/// // source ArrayHandles are read-only, the inverse functor will not be used
|
|
|
|
/// // and the ArrayHandleDecorator will be read only.
|
|
|
|
/// //
|
|
|
|
/// // Both SomeInverseFunctor::operator() and CreateInverseFunctor must be
|
|
|
|
/// // const.
|
|
|
|
/// //
|
|
|
|
/// template <typename Portal1Type, typename Portal2Type>
|
2019-12-20 21:18:09 +00:00
|
|
|
/// VTKM_CONT
|
2019-09-06 22:24:27 +00:00
|
|
|
/// SomeInverseFunctor CreateInverseFunctor(Portal1Type portal1,
|
|
|
|
/// Portal2Type portal2) const;
|
|
|
|
///
|
2019-12-20 22:03:36 +00:00
|
|
|
/// // Given a set of ArrayHandles and a size, implement what should happen
|
|
|
|
/// // to the source ArrayHandles when Allocate() is called on the decorator
|
|
|
|
/// // handle.
|
|
|
|
/// //
|
|
|
|
/// // AllocateSourceArrays is optional; if not provided, the
|
|
|
|
/// // ArrayHandleDecorator will throw if its Allocate method is called. If
|
|
|
|
/// // an implementation is present and doesn't throw, the
|
|
|
|
/// // ArrayHandleDecorator's internal state is updated to show `size` as the
|
|
|
|
/// // number of values.
|
|
|
|
/// template <typename Array1Type, typename Array2Type>
|
|
|
|
/// VTKM_CONT
|
2020-11-19 19:16:36 +00:00
|
|
|
/// void AllocateSourceArrays(vtkm::Id size,
|
|
|
|
/// vtkm::CopyFlag preserve,
|
|
|
|
/// vtkm::cont::Token& token,
|
|
|
|
/// Array1Type array1,
|
|
|
|
/// Array2Type array2) const;
|
2019-12-20 22:03:36 +00:00
|
|
|
///
|
2019-09-06 22:24:27 +00:00
|
|
|
/// };
|
|
|
|
/// ```
|
|
|
|
///
|
|
|
|
/// There are several example DecoratorImpl classes provided in the
|
|
|
|
/// UnitTestArrayHandleDecorator test file.
|
|
|
|
///
|
|
|
|
template <typename DecoratorImplT, typename... ArrayTs>
|
|
|
|
class ArrayHandleDecorator
|
|
|
|
: public internal::DecoratorHandleTraits<typename std::decay<DecoratorImplT>::type,
|
|
|
|
typename std::decay<ArrayTs>::type...>::Superclass
|
|
|
|
{
|
|
|
|
private:
|
|
|
|
using Traits = internal::DecoratorHandleTraits<typename std::decay<DecoratorImplT>::type,
|
|
|
|
typename std::decay<ArrayTs>::type...>;
|
|
|
|
|
|
|
|
public:
|
|
|
|
VTKM_ARRAY_HANDLE_SUBCLASS(ArrayHandleDecorator,
|
|
|
|
(ArrayHandleDecorator<typename std::decay<DecoratorImplT>::type,
|
|
|
|
typename std::decay<ArrayTs>::type...>),
|
|
|
|
(typename Traits::Superclass));
|
|
|
|
|
|
|
|
VTKM_CONT
|
|
|
|
ArrayHandleDecorator(vtkm::Id numValues,
|
|
|
|
const typename std::decay<DecoratorImplT>::type& impl,
|
|
|
|
const typename std::decay<ArrayTs>::type&... arrays)
|
2020-11-19 19:16:36 +00:00
|
|
|
: Superclass{ StorageType::CreateBuffers(impl, numValues, arrays...) }
|
2019-09-06 22:24:27 +00:00
|
|
|
{
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
/// Create an ArrayHandleDecorator with the specified number of values that
|
|
|
|
/// uses the provided DecoratorImplT and source ArrayHandles.
|
|
|
|
///
|
|
|
|
template <typename DecoratorImplT, typename... ArrayTs>
|
|
|
|
VTKM_CONT ArrayHandleDecorator<typename std::decay<DecoratorImplT>::type,
|
|
|
|
typename std::decay<ArrayTs>::type...>
|
|
|
|
make_ArrayHandleDecorator(vtkm::Id numValues, DecoratorImplT&& f, ArrayTs&&... arrays)
|
|
|
|
{
|
2022-02-09 19:56:46 +00:00
|
|
|
using AHList = vtkm::List<typename std::decay<ArrayTs>::type...>;
|
2019-09-06 22:24:27 +00:00
|
|
|
VTKM_STATIC_ASSERT_MSG(sizeof...(ArrayTs) > 0,
|
|
|
|
"Must specify at least one source array handle for "
|
|
|
|
"ArrayHandleDecorator. Consider using "
|
|
|
|
"ArrayHandleImplicit instead.");
|
|
|
|
VTKM_STATIC_ASSERT_MSG(internal::decor::AllAreArrayHandles<AHList>::value,
|
|
|
|
"Trailing template parameters for "
|
|
|
|
"ArrayHandleDecorator must be a list of ArrayHandle "
|
|
|
|
"types.");
|
|
|
|
|
|
|
|
return { numValues, std::forward<DecoratorImplT>(f), std::forward<ArrayTs>(arrays)... };
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} // namespace vtkm::cont
|
|
|
|
|
2019-12-10 23:16:30 +00:00
|
|
|
#ifdef VTKM_USE_TAO_SEQ
|
|
|
|
#undef VTKM_USE_TAO_SEQ
|
|
|
|
#endif
|
2019-09-27 21:02:06 +00:00
|
|
|
|
2019-09-06 22:24:27 +00:00
|
|
|
#endif //vtk_m_ArrayHandleDecorator_h
|