Merge branch 'master' of https://gitlab.kitware.com/vtk/vtk-m into threaded_particleAdvection
This commit is contained in:
commit
9cdcddb0c3
@ -149,6 +149,7 @@ mark_as_advanced(
|
||||
VTKm_ENABLE_LOGGING
|
||||
VTKm_NO_ASSERT
|
||||
VTKm_NO_ASSERT_CUDA
|
||||
VTKm_NO_ASSERT_HIP
|
||||
VTKm_INSTALL_ONLY_LIBRARIES
|
||||
VTKm_HIDE_PRIVATE_SYMBOLS
|
||||
VTKm_ENABLE_DEVELOPER_FLAGS
|
||||
|
@ -1109,7 +1109,7 @@ public:
|
||||
return true; // different valuetype and/or storage
|
||||
}
|
||||
|
||||
VTKM_CONT constexpr vtkm::IdComponent GetNumberOfBuffers() const
|
||||
VTKM_CONT static constexpr vtkm::IdComponent GetNumberOfBuffers()
|
||||
{
|
||||
return StorageType::GetNumberOfBuffers();
|
||||
}
|
||||
|
@ -29,8 +29,6 @@
|
||||
|
||||
namespace vtkm
|
||||
{
|
||||
namespace cont
|
||||
{
|
||||
namespace internal
|
||||
{
|
||||
|
||||
@ -94,6 +92,16 @@ private:
|
||||
InverseFunctorType InverseFunctor;
|
||||
vtkm::Id NumberOfValues;
|
||||
};
|
||||
}
|
||||
} // namespace vtkm::internal
|
||||
|
||||
namespace vtkm
|
||||
{
|
||||
namespace cont
|
||||
{
|
||||
|
||||
namespace internal
|
||||
{
|
||||
|
||||
namespace decor
|
||||
{
|
||||
@ -137,26 +145,10 @@ struct IsDecoratorAllocatableImpl<DecoratorImplT, List<ArrayTs...>>
|
||||
private:
|
||||
template <
|
||||
typename T,
|
||||
typename U = decltype(std::declval<T>().AllocateSourceArrays(0, std::declval<ArrayTs&>()...))>
|
||||
static std::true_type Exists(int);
|
||||
template <typename T>
|
||||
static std::false_type Exists(...);
|
||||
|
||||
public:
|
||||
using type = decltype(Exists<DecoratorImplT>(0));
|
||||
};
|
||||
|
||||
// Tests whether DecoratorImplT has a ShrinkSourceArrays(size, Arrays...) method.
|
||||
template <typename DecoratorImplT, typename ArrayList>
|
||||
struct IsDecoratorShrinkableImpl;
|
||||
|
||||
template <typename DecoratorImplT, template <typename...> class List, typename... ArrayTs>
|
||||
struct IsDecoratorShrinkableImpl<DecoratorImplT, List<ArrayTs...>>
|
||||
{
|
||||
private:
|
||||
template <
|
||||
typename T,
|
||||
typename U = decltype(std::declval<T>().ShrinkSourceArrays(0, std::declval<ArrayTs&>()...))>
|
||||
typename U = decltype(std::declval<T>().AllocateSourceArrays(0,
|
||||
vtkm::CopyFlag::Off,
|
||||
std::declval<vtkm::cont::Token&>(),
|
||||
std::declval<ArrayTs&>()...))>
|
||||
static std::true_type Exists(int);
|
||||
template <typename T>
|
||||
static std::false_type Exists(...);
|
||||
@ -193,56 +185,30 @@ struct GetInverseFunctorTypeImpl<std::true_type, DecoratorImplT, List<PortalTs..
|
||||
template <typename DecoratorImplT, typename PortalList>
|
||||
struct GetInverseFunctorTypeImpl<std::false_type, DecoratorImplT, PortalList>
|
||||
{
|
||||
using type = NoOpInverseFunctor;
|
||||
using type = vtkm::internal::decor::NoOpInverseFunctor;
|
||||
};
|
||||
|
||||
// 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>
|
||||
typename std::decay<ArrayT>::type::WritePortalType GetPortalControlImpl(std::true_type,
|
||||
ArrayT&& array)
|
||||
typename std::decay<ArrayT>::type::WritePortalType GetWritePortalImpl(
|
||||
std::true_type,
|
||||
ArrayT&& array,
|
||||
vtkm::cont::DeviceAdapterId device,
|
||||
vtkm::cont::Token& token)
|
||||
{
|
||||
return array.WritePortal();
|
||||
return ArrayT::StorageType::CreateWritePortal(array.GetBuffers(), device, token);
|
||||
}
|
||||
|
||||
template <typename ArrayT>
|
||||
typename std::decay<ArrayT>::type::ReadPortalType GetPortalControlImpl(std::false_type,
|
||||
ArrayT&& array)
|
||||
typename std::decay<ArrayT>::type::ReadPortalType GetWritePortalImpl(
|
||||
std::false_type,
|
||||
ArrayT&& array,
|
||||
vtkm::cont::DeviceAdapterId device,
|
||||
vtkm::cont::Token& token)
|
||||
{
|
||||
return array.ReadPortal();
|
||||
}
|
||||
|
||||
template <typename ArrayT, typename Device>
|
||||
typename std::decay<ArrayT>::type::template ExecutionTypes<Device>::Portal
|
||||
GetPortalInPlaceImpl(std::true_type, ArrayT&& array, Device, vtkm::cont::Token& token)
|
||||
{
|
||||
return array.PrepareForInPlace(Device{}, token);
|
||||
}
|
||||
|
||||
template <typename ArrayT, typename Device>
|
||||
typename std::decay<ArrayT>::type::template ExecutionTypes<Device>::PortalConst
|
||||
GetPortalInPlaceImpl(std::false_type, ArrayT&& array, Device, vtkm::cont::Token& token)
|
||||
{
|
||||
// ArrayT is read-only -- prepare for input instead.
|
||||
return array.PrepareForInput(Device{}, token);
|
||||
}
|
||||
|
||||
template <typename ArrayT, typename Device>
|
||||
typename std::decay<ArrayT>::type::template ExecutionTypes<Device>::Portal
|
||||
GetPortalOutputImpl(std::true_type, ArrayT&& array, Device, vtkm::cont::Token& token)
|
||||
{
|
||||
// Prepare these for inplace usage instead -- we'll likely need to read
|
||||
// from these in addition to writing.
|
||||
return array.PrepareForInPlace(Device{}, token);
|
||||
}
|
||||
|
||||
template <typename ArrayT, typename Device>
|
||||
typename std::decay<ArrayT>::type::template ExecutionTypes<Device>::PortalConst
|
||||
GetPortalOutputImpl(std::false_type, ArrayT&& array, Device, vtkm::cont::Token& token)
|
||||
{
|
||||
// ArrayT is read-only -- prepare for input instead.
|
||||
return array.PrepareForInput(Device{}, token);
|
||||
return ArrayT::StorageType::CreateReadPortal(array.GetBuffers(), device, token);
|
||||
}
|
||||
|
||||
} // namespace detail
|
||||
@ -256,11 +222,11 @@ GetPortalOutputImpl(std::false_type, ArrayT&& array, Device, vtkm::cont::Token&
|
||||
template <typename ArrayT,
|
||||
typename Portal = typename std::decay<ArrayT>::type::WritePortalType,
|
||||
typename PortalConst = typename std::decay<ArrayT>::type::ReadPortalType>
|
||||
using GetPortalControlType =
|
||||
using GetWritePortalType =
|
||||
typename brigand::if_<vtkm::internal::PortalSupportsSets<Portal>, Portal, PortalConst>::type;
|
||||
|
||||
template <typename ArrayT>
|
||||
using GetPortalConstControlType = typename std::decay<ArrayT>::type::ReadPortalType;
|
||||
using GetReadPortalType = typename std::decay<ArrayT>::type::ReadPortalType;
|
||||
|
||||
template <typename ArrayT,
|
||||
typename Device,
|
||||
@ -278,38 +244,19 @@ using GetPortalConstExecutionType =
|
||||
// Get portal objects:
|
||||
// See note above -- we swap in const portals sometimes.
|
||||
template <typename ArrayT>
|
||||
GetPortalControlType<typename std::decay<ArrayT>::type> WritePortal(ArrayT&& array)
|
||||
GetWritePortalType<typename std::decay<ArrayT>::type>
|
||||
WritePortal(ArrayT&& array, vtkm::cont::DeviceAdapterId device, vtkm::cont::Token& token)
|
||||
{
|
||||
return detail::GetPortalControlImpl(IsWritableArrayHandle<ArrayT>{}, std::forward<ArrayT>(array));
|
||||
return detail::GetWritePortalImpl(
|
||||
IsWritableArrayHandle<ArrayT>{}, std::forward<ArrayT>(array), device, token);
|
||||
}
|
||||
|
||||
template <typename ArrayT>
|
||||
GetPortalConstControlType<typename std::decay<ArrayT>::type> ReadPortal(const ArrayT& array)
|
||||
GetReadPortalType<typename std::decay<ArrayT>::type> ReadPortal(const ArrayT& array,
|
||||
vtkm::cont::DeviceAdapterId device,
|
||||
vtkm::cont::Token& token)
|
||||
{
|
||||
return array.ReadPortal();
|
||||
}
|
||||
|
||||
template <typename ArrayT, typename Device>
|
||||
GetPortalConstExecutionType<typename std::decay<ArrayT>::type, Device>
|
||||
GetPortalInput(const ArrayT& array, Device, vtkm::cont::Token& token)
|
||||
{
|
||||
return array.PrepareForInput(Device{}, token);
|
||||
}
|
||||
|
||||
template <typename ArrayT, typename Device>
|
||||
GetPortalExecutionType<typename std::decay<ArrayT>::type, Device>
|
||||
GetPortalInPlace(ArrayT&& array, Device, vtkm::cont::Token& token)
|
||||
{
|
||||
return detail::GetPortalInPlaceImpl(
|
||||
IsWritableArrayHandle<ArrayT>{}, std::forward<ArrayT>(array), Device{}, token);
|
||||
}
|
||||
|
||||
template <typename ArrayT, typename Device>
|
||||
GetPortalExecutionType<typename std::decay<ArrayT>::type, Device>
|
||||
GetPortalOutput(ArrayT&& array, Device, vtkm::cont::Token& token)
|
||||
{
|
||||
return detail::GetPortalOutputImpl(
|
||||
IsWritableArrayHandle<ArrayT>{}, std::forward<ArrayT>(array), Device{}, token);
|
||||
return ArrayT::StorageType::CreateReadPortal(array.GetBuffers(), device, token);
|
||||
}
|
||||
|
||||
// Equivalent to std::true_type if *any* portal in PortalList can be written to.
|
||||
@ -331,12 +278,6 @@ template <typename DecoratorImplT, typename ArrayList>
|
||||
using IsDecoratorAllocatable =
|
||||
typename detail::IsDecoratorAllocatableImpl<DecoratorImplT, ArrayList>::type;
|
||||
|
||||
// Set to std::true_type if DecoratorImplT::ShrinkSourceArrays can be called
|
||||
// with the supplied arrays, or std::false_type otherwise.
|
||||
template <typename DecoratorImplT, typename ArrayList>
|
||||
using IsDecoratorShrinkable =
|
||||
typename detail::IsDecoratorShrinkableImpl<DecoratorImplT, ArrayList>::type;
|
||||
|
||||
// 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>
|
||||
@ -360,23 +301,54 @@ using GetInverseFunctorType =
|
||||
// Some notes on this implementation:
|
||||
// - MSVC 2015 ICEs when using brigand::transform to convert a brigand::list
|
||||
// of arrayhandles to portals. So instead we pass the ArrayTs.
|
||||
// - Just using brigand::list<GetPortalControlType<ArrayTs>...> fails, as
|
||||
// - Just using brigand::list<GetWritePortalType<ArrayTs>...> fails, as
|
||||
// apparently that is an improper parameter pack expansion
|
||||
// - So we jump through some decltype/declval hoops here to get this to work:
|
||||
template <typename... ArrayTs>
|
||||
using GetPortalConstControlList =
|
||||
brigand::list<decltype((ReadPortal(std::declval<ArrayTs&>())))...>;
|
||||
|
||||
template <typename Device, typename... ArrayTs>
|
||||
using GetPortalConstExecutionList = brigand::list<decltype(
|
||||
(GetPortalInput(std::declval<ArrayTs&>(), Device{}, std::declval<vtkm::cont::Token&>())))...>;
|
||||
using GetReadPortalList =
|
||||
brigand::list<decltype((ReadPortal(std::declval<ArrayTs&>(),
|
||||
std::declval<vtkm::cont::DeviceAdapterId>(),
|
||||
std::declval<vtkm::cont::Token&>())))...>;
|
||||
|
||||
template <typename... ArrayTs>
|
||||
using GetPortalControlList = brigand::list<decltype((WritePortal(std::declval<ArrayTs&>())))...>;
|
||||
using GetWritePortalList =
|
||||
brigand::list<decltype((WritePortal(std::declval<ArrayTs&>(),
|
||||
std::declval<vtkm::cont::DeviceAdapterId>(),
|
||||
std::declval<vtkm::cont::Token&>())))...>;
|
||||
|
||||
template <typename Device, typename... ArrayTs>
|
||||
using GetPortalExecutionList = brigand::list<decltype(
|
||||
(GetPortalInPlace(std::declval<ArrayTs&>(), Device{}, std::declval<vtkm::cont::Token&>())))...>;
|
||||
template <vtkm::IdComponent I, typename ArrayTupleType>
|
||||
struct BufferIndexImpl
|
||||
{
|
||||
static constexpr vtkm::IdComponent Value()
|
||||
{
|
||||
return BufferIndexImpl<I - 1, ArrayTupleType>::Value() +
|
||||
vtkm::TupleElement<I - 1, ArrayTupleType>::GetNumberOfBuffers();
|
||||
}
|
||||
};
|
||||
template <typename ArrayTupleType>
|
||||
struct BufferIndexImpl<0, ArrayTupleType>
|
||||
{
|
||||
static constexpr vtkm::IdComponent Value()
|
||||
{
|
||||
// One buffer reserved for metadata.
|
||||
return 1;
|
||||
}
|
||||
};
|
||||
|
||||
template <typename DecoratorImplT>
|
||||
struct DecoratorMetaData
|
||||
{
|
||||
DecoratorImplT Implementation;
|
||||
vtkm::Id NumberOfValues = 0;
|
||||
|
||||
DecoratorMetaData(const DecoratorImplT& implementation, vtkm::Id numValues)
|
||||
: Implementation(implementation)
|
||||
, NumberOfValues(numValues)
|
||||
{
|
||||
}
|
||||
|
||||
DecoratorMetaData() = default;
|
||||
};
|
||||
|
||||
template <typename DecoratorImplT, typename... ArrayTs>
|
||||
struct DecoratorStorageTraits
|
||||
@ -401,63 +373,56 @@ struct DecoratorStorageTraits
|
||||
// size_t integral constants that index ArrayTs:
|
||||
using IndexList = vtkmstd::make_index_sequence<sizeof...(ArrayTs)>;
|
||||
|
||||
// true_type/false_type depending on whether the decorator supports Allocate/Shrink:
|
||||
// Returns the index into the buffers array for the array at the given index.
|
||||
template <vtkm::IdComponent I>
|
||||
static constexpr vtkm::IdComponent BufferIndex()
|
||||
{
|
||||
return BufferIndexImpl<I, ArrayTupleType>::Value();
|
||||
}
|
||||
|
||||
// Converts a buffers array to the ArrayHandle at the given index.
|
||||
template <vtkm::IdComponent I>
|
||||
static vtkm::TupleElement<I, ArrayTupleType> BuffersToArray(
|
||||
const vtkm::cont::internal::Buffer* buffers)
|
||||
{
|
||||
return vtkm::TupleElement<I, ArrayTupleType>(buffers + BufferIndex<I>());
|
||||
}
|
||||
|
||||
using MetaData = DecoratorMetaData<DecoratorImplT>;
|
||||
|
||||
static MetaData& GetMetaData(const vtkm::cont::internal::Buffer* buffers)
|
||||
{
|
||||
return buffers[0].GetMetaData<MetaData>();
|
||||
}
|
||||
|
||||
// true_type/false_type depending on whether the decorator supports Allocate:
|
||||
using IsAllocatable = IsDecoratorAllocatable<DecoratorImplT, ArrayList>;
|
||||
using IsShrinkable = IsDecoratorShrinkable<DecoratorImplT, ArrayList>;
|
||||
|
||||
// Portal lists:
|
||||
// NOTE we have to pass the parameter pack here instead of using ArrayList
|
||||
// with brigand::transform, since that's causing MSVC 2015 to ice:
|
||||
using PortalControlList = GetPortalControlList<ArrayTs...>;
|
||||
using PortalConstControlList = GetPortalConstControlList<ArrayTs...>;
|
||||
template <typename Device>
|
||||
using PortalExecutionList = GetPortalExecutionList<Device, ArrayTs...>;
|
||||
template <typename Device>
|
||||
using PortalConstExecutionList = GetPortalConstExecutionList<Device, ArrayTs...>;
|
||||
using WritePortalList = GetWritePortalList<ArrayTs...>;
|
||||
using ReadPortalList = GetReadPortalList<ArrayTs...>;
|
||||
|
||||
// Functors:
|
||||
using FunctorControlType = GetFunctorType<DecoratorImplT, PortalControlList>;
|
||||
using FunctorConstControlType = GetFunctorType<DecoratorImplT, PortalConstControlList>;
|
||||
|
||||
template <typename Device>
|
||||
using FunctorExecutionType = GetFunctorType<DecoratorImplT, PortalExecutionList<Device>>;
|
||||
|
||||
template <typename Device>
|
||||
using FunctorConstExecutionType =
|
||||
GetFunctorType<DecoratorImplT, PortalConstExecutionList<Device>>;
|
||||
using WriteFunctorType = GetFunctorType<DecoratorImplT, WritePortalList>;
|
||||
using ReadFunctorType = GetFunctorType<DecoratorImplT, ReadPortalList>;
|
||||
|
||||
// Inverse functors:
|
||||
using InverseFunctorControlType = GetInverseFunctorType<DecoratorImplT, PortalControlList>;
|
||||
using InverseWriteFunctorType = GetInverseFunctorType<DecoratorImplT, WritePortalList>;
|
||||
|
||||
using InverseFunctorConstControlType = NoOpInverseFunctor;
|
||||
|
||||
template <typename Device>
|
||||
using InverseFunctorExecutionType =
|
||||
GetInverseFunctorType<DecoratorImplT, PortalExecutionList<Device>>;
|
||||
|
||||
template <typename Device>
|
||||
using InverseFunctorConstExecutionType = NoOpInverseFunctor;
|
||||
using InverseReadFunctorType = vtkm::internal::decor::NoOpInverseFunctor;
|
||||
|
||||
// Misc:
|
||||
// ValueType is derived from DecoratorImplT::CreateFunctor(...)'s operator().
|
||||
using ValueType = decltype(std::declval<FunctorControlType>()(0));
|
||||
using ValueType = decltype(std::declval<WriteFunctorType>()(0));
|
||||
|
||||
// Decorator portals:
|
||||
using PortalControlType =
|
||||
ArrayPortalDecorator<ValueType, FunctorControlType, InverseFunctorControlType>;
|
||||
using WritePortalType =
|
||||
vtkm::internal::ArrayPortalDecorator<ValueType, WriteFunctorType, InverseWriteFunctorType>;
|
||||
|
||||
using PortalConstControlType =
|
||||
ArrayPortalDecorator<ValueType, FunctorConstControlType, InverseFunctorConstControlType>;
|
||||
|
||||
template <typename Device>
|
||||
using PortalExecutionType = ArrayPortalDecorator<ValueType,
|
||||
FunctorExecutionType<Device>,
|
||||
InverseFunctorExecutionType<Device>>;
|
||||
|
||||
template <typename Device>
|
||||
using PortalConstExecutionType = ArrayPortalDecorator<ValueType,
|
||||
FunctorConstExecutionType<Device>,
|
||||
InverseFunctorConstExecutionType<Device>>;
|
||||
using ReadPortalType =
|
||||
vtkm::internal::ArrayPortalDecorator<ValueType, ReadFunctorType, InverseReadFunctorType>;
|
||||
|
||||
// helper for constructing portals with the appropriate functors. This is
|
||||
// where we decide whether or not to call `CreateInverseFunctor` on the
|
||||
@ -484,115 +449,64 @@ struct DecoratorStorageTraits
|
||||
|
||||
// Static dispatch for calling AllocateSourceArrays on supported implementations:
|
||||
VTKM_CONT [[noreturn]] static void CallAllocate(std::false_type,
|
||||
const DecoratorImplT&,
|
||||
vtkm::Id,
|
||||
ArrayTs&...)
|
||||
vtkm::cont::internal::Buffer*,
|
||||
vtkm::CopyFlag,
|
||||
vtkm::cont::Token&,
|
||||
ArrayTs...)
|
||||
{
|
||||
throw vtkm::cont::ErrorBadType("Allocate not supported by this ArrayHandleDecorator.");
|
||||
}
|
||||
|
||||
VTKM_CONT static void CallAllocate(std::true_type,
|
||||
const DecoratorImplT& impl,
|
||||
vtkm::Id newSize,
|
||||
ArrayTs&... arrays)
|
||||
vtkm::cont::internal::Buffer* buffers,
|
||||
vtkm::CopyFlag preserve,
|
||||
vtkm::cont::Token& token,
|
||||
ArrayTs... arrays)
|
||||
{
|
||||
impl.AllocateSourceArrays(newSize, arrays...);
|
||||
}
|
||||
|
||||
// Static dispatch for calling ShrinkSourceArrays on supported implementations.
|
||||
VTKM_CONT [[noreturn]] static void CallShrink(std::false_type,
|
||||
const DecoratorImplT&,
|
||||
vtkm::Id,
|
||||
ArrayTs&...)
|
||||
{
|
||||
throw vtkm::cont::ErrorBadType("Shrink not supported by this ArrayHandleDecorator.");
|
||||
}
|
||||
|
||||
VTKM_CONT static void CallShrink(std::true_type,
|
||||
const DecoratorImplT& impl,
|
||||
vtkm::Id newSize,
|
||||
ArrayTs&... arrays)
|
||||
{
|
||||
impl.ShrinkSourceArrays(newSize, arrays...);
|
||||
MetaData& metadata = GetMetaData(buffers);
|
||||
metadata.Implementation.AllocateSourceArrays(newSize, preserve, token, arrays...);
|
||||
metadata.NumberOfValues = newSize;
|
||||
}
|
||||
|
||||
|
||||
// Portal construction methods. These actually create portals.
|
||||
template <std::size_t... Indices>
|
||||
VTKM_CONT static PortalControlType MakePortalControl(const DecoratorImplT& impl,
|
||||
ArrayTupleType& arrays,
|
||||
vtkm::Id numValues,
|
||||
vtkmstd::index_sequence<Indices...>)
|
||||
VTKM_CONT static WritePortalType CreateWritePortal(const vtkm::cont::internal::Buffer* buffers,
|
||||
vtkm::Id numValues,
|
||||
vtkmstd::index_sequence<Indices...>,
|
||||
vtkm::cont::DeviceAdapterId device,
|
||||
vtkm::cont::Token& token)
|
||||
{
|
||||
return CreatePortalDecorator<PortalControlType>(
|
||||
numValues, impl, WritePortal(vtkm::Get<Indices>(arrays))...);
|
||||
return CreatePortalDecorator<WritePortalType>(
|
||||
numValues,
|
||||
GetMetaData(buffers).Implementation,
|
||||
WritePortal(BuffersToArray<Indices>(buffers), device, token)...);
|
||||
}
|
||||
|
||||
template <std::size_t... Indices>
|
||||
VTKM_CONT static PortalConstControlType MakePortalConstControl(
|
||||
const DecoratorImplT& impl,
|
||||
const ArrayTupleType& arrays,
|
||||
vtkm::Id numValues,
|
||||
vtkmstd::index_sequence<Indices...>)
|
||||
VTKM_CONT static ReadPortalType CreateReadPortal(const vtkm::cont::internal::Buffer* buffers,
|
||||
vtkm::Id numValues,
|
||||
vtkmstd::index_sequence<Indices...>,
|
||||
vtkm::cont::DeviceAdapterId device,
|
||||
vtkm::cont::Token& token)
|
||||
{
|
||||
return CreatePortalDecorator<PortalConstControlType>(
|
||||
numValues, impl, ReadPortal(vtkm::Get<Indices>(arrays))...);
|
||||
}
|
||||
|
||||
template <typename Device, std::size_t... Indices>
|
||||
VTKM_CONT static PortalConstExecutionType<Device> MakePortalInput(
|
||||
const DecoratorImplT& impl,
|
||||
const ArrayTupleType& arrays,
|
||||
vtkm::Id numValues,
|
||||
vtkmstd::index_sequence<Indices...>,
|
||||
Device dev,
|
||||
vtkm::cont::Token& token)
|
||||
{
|
||||
return CreatePortalDecorator<PortalConstExecutionType<Device>>(
|
||||
numValues, impl, GetPortalInput(vtkm::Get<Indices>(arrays), dev, token)...);
|
||||
}
|
||||
|
||||
template <typename Device, std::size_t... Indices>
|
||||
VTKM_CONT static PortalExecutionType<Device> MakePortalInPlace(
|
||||
const DecoratorImplT& impl,
|
||||
ArrayTupleType& arrays,
|
||||
vtkm::Id numValues,
|
||||
vtkmstd::index_sequence<Indices...>,
|
||||
Device dev,
|
||||
vtkm::cont::Token& token)
|
||||
{
|
||||
return CreatePortalDecorator<PortalExecutionType<Device>>(
|
||||
numValues, impl, GetPortalInPlace(vtkm::Get<Indices>(arrays), dev, token)...);
|
||||
}
|
||||
|
||||
template <typename Device, std::size_t... Indices>
|
||||
VTKM_CONT static PortalExecutionType<Device> MakePortalOutput(const DecoratorImplT& impl,
|
||||
ArrayTupleType& arrays,
|
||||
vtkm::Id numValues,
|
||||
vtkmstd::index_sequence<Indices...>,
|
||||
Device dev,
|
||||
vtkm::cont::Token& token)
|
||||
{
|
||||
return CreatePortalDecorator<PortalExecutionType<Device>>(
|
||||
numValues, impl, GetPortalOutput(vtkm::Get<Indices>(arrays), dev, token)...);
|
||||
return CreatePortalDecorator<ReadPortalType>(
|
||||
numValues,
|
||||
GetMetaData(buffers).Implementation,
|
||||
ReadPortal(BuffersToArray<Indices>(buffers), device, token)...);
|
||||
}
|
||||
|
||||
template <std::size_t... Indices>
|
||||
VTKM_CONT static void AllocateSourceArrays(const DecoratorImplT& impl,
|
||||
ArrayTupleType& arrays,
|
||||
vtkm::Id numValues,
|
||||
VTKM_CONT static void AllocateSourceArrays(vtkm::Id numValues,
|
||||
vtkm::cont::internal::Buffer* buffers,
|
||||
vtkm::CopyFlag preserve,
|
||||
vtkm::cont::Token& token,
|
||||
vtkmstd::index_sequence<Indices...>)
|
||||
{
|
||||
CallAllocate(IsAllocatable{}, impl, numValues, vtkm::Get<Indices>(arrays)...);
|
||||
}
|
||||
|
||||
template <std::size_t... Indices>
|
||||
VTKM_CONT static void ShrinkSourceArrays(const DecoratorImplT& impl,
|
||||
ArrayTupleType& arrays,
|
||||
vtkm::Id numValues,
|
||||
vtkmstd::index_sequence<Indices...>)
|
||||
{
|
||||
CallShrink(IsShrinkable{}, impl, numValues, vtkm::Get<Indices>(arrays)...);
|
||||
CallAllocate(
|
||||
IsAllocatable{}, numValues, buffers, preserve, token, BuffersToArray<Indices>(buffers)...);
|
||||
}
|
||||
};
|
||||
|
||||
@ -609,110 +523,59 @@ class Storage<typename decor::DecoratorStorageTraits<DecoratorImplT, ArrayTs...>
|
||||
{
|
||||
using Traits = decor::DecoratorStorageTraits<DecoratorImplT, ArrayTs...>;
|
||||
using IndexList = typename Traits::IndexList;
|
||||
using MetaData = typename Traits::MetaData;
|
||||
|
||||
public:
|
||||
using ArrayTupleType = typename Traits::ArrayTupleType;
|
||||
using ValueType = typename Traits::ValueType;
|
||||
using PortalType = typename Traits::PortalControlType;
|
||||
using PortalConstType = typename Traits::PortalConstControlType;
|
||||
using ReadPortalType = typename Traits::ReadPortalType;
|
||||
using WritePortalType = typename Traits::WritePortalType;
|
||||
|
||||
VTKM_CONT
|
||||
Storage()
|
||||
: Valid{ false }
|
||||
VTKM_CONT constexpr static vtkm::IdComponent GetNumberOfBuffers()
|
||||
{
|
||||
return Traits::template BufferIndex<static_cast<vtkm::IdComponent>(sizeof...(ArrayTs))>();
|
||||
}
|
||||
|
||||
VTKM_CONT
|
||||
Storage(const DecoratorImplT& impl, const ArrayTupleType& arrayTuple, vtkm::Id numValues)
|
||||
: Implementation(impl)
|
||||
, ArrayTuple{ arrayTuple }
|
||||
, NumberOfValues(numValues)
|
||||
, Valid{ true }
|
||||
VTKM_CONT static vtkm::Id GetNumberOfValues(const vtkm::cont::internal::Buffer* buffers)
|
||||
{
|
||||
return Traits::GetMetaData(buffers).NumberOfValues;
|
||||
}
|
||||
|
||||
VTKM_CONT
|
||||
PortalType GetPortal()
|
||||
VTKM_CONT static void ResizeBuffers(vtkm::Id numValues,
|
||||
vtkm::cont::internal::Buffer* buffers,
|
||||
vtkm::CopyFlag preserve,
|
||||
vtkm::cont::Token& token)
|
||||
{
|
||||
VTKM_ASSERT(this->Valid);
|
||||
return Traits::MakePortalControl(
|
||||
this->Implementation, this->ArrayTuple, this->NumberOfValues, IndexList{});
|
||||
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.
|
||||
}
|
||||
}
|
||||
|
||||
VTKM_CONT
|
||||
PortalConstType GetPortalConst() const
|
||||
VTKM_CONT static ReadPortalType CreateReadPortal(const vtkm::cont::internal::Buffer* buffers,
|
||||
vtkm::cont::DeviceAdapterId device,
|
||||
vtkm::cont::Token& token)
|
||||
{
|
||||
VTKM_ASSERT(this->Valid);
|
||||
return Traits::MakePortalConstControl(
|
||||
this->Implementation, this->ArrayTuple, this->NumberOfValues, IndexList{});
|
||||
return Traits::CreateReadPortal(
|
||||
buffers, GetNumberOfValues(buffers), IndexList{}, device, token);
|
||||
}
|
||||
|
||||
VTKM_CONT
|
||||
vtkm::Id GetNumberOfValues() const
|
||||
VTKM_CONT static WritePortalType CreateWritePortal(vtkm::cont::internal::Buffer* buffers,
|
||||
vtkm::cont::DeviceAdapterId device,
|
||||
vtkm::cont::Token& token)
|
||||
{
|
||||
VTKM_ASSERT(this->Valid);
|
||||
return this->NumberOfValues;
|
||||
return Traits::CreateWritePortal(
|
||||
buffers, GetNumberOfValues(buffers), IndexList{}, device, token);
|
||||
}
|
||||
|
||||
VTKM_CONT
|
||||
void Allocate(vtkm::Id numValues)
|
||||
VTKM_CONT static std::vector<vtkm::cont::internal::Buffer>
|
||||
CreateBuffers(const DecoratorImplT& implementation, vtkm::Id numValues, const ArrayTs&... arrays)
|
||||
{
|
||||
VTKM_ASSERT(this->Valid);
|
||||
Traits::AllocateSourceArrays(this->Implementation, this->ArrayTuple, numValues, IndexList{});
|
||||
// If the above call doesn't throw, update our state.
|
||||
this->NumberOfValues = numValues;
|
||||
return vtkm::cont::internal::CreateBuffers(MetaData(implementation, numValues), arrays...);
|
||||
}
|
||||
|
||||
VTKM_CONT
|
||||
void Shrink(vtkm::Id numValues)
|
||||
{
|
||||
VTKM_ASSERT(this->Valid);
|
||||
Traits::ShrinkSourceArrays(this->Implementation, this->ArrayTuple, numValues, IndexList{});
|
||||
// If the above call doesn't throw, update our state.
|
||||
this->NumberOfValues = numValues;
|
||||
}
|
||||
|
||||
VTKM_CONT
|
||||
void ReleaseResources()
|
||||
{
|
||||
VTKM_ASSERT(this->Valid);
|
||||
// No-op. Again, could eventually be passed down to the implementation.
|
||||
}
|
||||
|
||||
VTKM_CONT
|
||||
const ArrayTupleType& GetArrayTuple() const
|
||||
{
|
||||
VTKM_ASSERT(this->Valid);
|
||||
return this->ArrayTuple;
|
||||
}
|
||||
|
||||
VTKM_CONT
|
||||
ArrayTupleType& GetArrayTuple()
|
||||
{
|
||||
VTKM_ASSERT(this->Valid);
|
||||
return this->ArrayTuple;
|
||||
}
|
||||
|
||||
VTKM_CONT
|
||||
const DecoratorImplT& GetImplementation() const
|
||||
{
|
||||
VTKM_ASSERT(this->Valid);
|
||||
return this->Implementation;
|
||||
}
|
||||
|
||||
VTKM_CONT
|
||||
DecoratorImplT& GetImplementation()
|
||||
{
|
||||
VTKM_ASSERT(this->Valid);
|
||||
return this->Implementation;
|
||||
}
|
||||
|
||||
private:
|
||||
DecoratorImplT Implementation;
|
||||
ArrayTupleType ArrayTuple;
|
||||
vtkm::Id NumberOfValues;
|
||||
|
||||
bool Valid;
|
||||
};
|
||||
|
||||
template <typename DecoratorImplT, typename... ArrayTs>
|
||||
@ -725,93 +588,13 @@ struct DecoratorHandleTraits
|
||||
using Superclass = vtkm::cont::ArrayHandle<ValueType, StorageTag>;
|
||||
};
|
||||
|
||||
template <typename DecoratorImplT, typename... ArrayTs, typename Device>
|
||||
class ArrayTransfer<typename decor::DecoratorStorageTraits<DecoratorImplT, ArrayTs...>::ValueType,
|
||||
StorageTagDecorator<DecoratorImplT, ArrayTs...>,
|
||||
Device>
|
||||
{
|
||||
VTKM_IS_DEVICE_ADAPTER_TAG(Device);
|
||||
|
||||
using HandleTraits = DecoratorHandleTraits<DecoratorImplT, ArrayTs...>;
|
||||
using Traits = typename HandleTraits::StorageTraits;
|
||||
using IndexList = typename Traits::IndexList;
|
||||
using StorageType = typename HandleTraits::StorageType;
|
||||
|
||||
public:
|
||||
using ValueType = typename Traits::ValueType;
|
||||
|
||||
using PortalControl = typename Traits::PortalControlType;
|
||||
using PortalConstControl = typename Traits::PortalConstControlType;
|
||||
|
||||
using PortalExecution = typename Traits::template PortalExecutionType<Device>;
|
||||
using PortalConstExecution = typename Traits::template PortalConstExecutionType<Device>;
|
||||
|
||||
VTKM_CONT
|
||||
ArrayTransfer(StorageType* storage)
|
||||
: Storage(storage)
|
||||
{
|
||||
}
|
||||
|
||||
VTKM_CONT
|
||||
vtkm::Id GetNumberOfValues() const { return this->Storage->GetNumberOfValues(); }
|
||||
|
||||
VTKM_CONT
|
||||
PortalConstExecution PrepareForInput(bool vtkmNotUsed(updateData), vtkm::cont::Token& token) const
|
||||
{
|
||||
return Traits::MakePortalInput(this->Storage->GetImplementation(),
|
||||
this->Storage->GetArrayTuple(),
|
||||
this->Storage->GetNumberOfValues(),
|
||||
IndexList{},
|
||||
Device{},
|
||||
token);
|
||||
}
|
||||
|
||||
VTKM_CONT
|
||||
PortalExecution PrepareForInPlace(bool vtkmNotUsed(updateData), vtkm::cont::Token& token)
|
||||
{
|
||||
return Traits::MakePortalInPlace(this->Storage->GetImplementation(),
|
||||
this->Storage->GetArrayTuple(),
|
||||
this->Storage->GetNumberOfValues(),
|
||||
IndexList{},
|
||||
Device{},
|
||||
token);
|
||||
}
|
||||
|
||||
VTKM_CONT
|
||||
PortalExecution PrepareForOutput(vtkm::Id, vtkm::cont::Token& token)
|
||||
{
|
||||
return Traits::MakePortalOutput(this->Storage->GetImplementation(),
|
||||
this->Storage->GetArrayTuple(),
|
||||
this->Storage->GetNumberOfValues(),
|
||||
IndexList{},
|
||||
Device{},
|
||||
token);
|
||||
}
|
||||
|
||||
VTKM_CONT
|
||||
void RetrieveOutputData(StorageType* vtkmNotUsed(storage)) const
|
||||
{
|
||||
// Implementation of this method should be unnecessary. The internal
|
||||
// array handles should automatically retrieve the output data as
|
||||
// necessary.
|
||||
}
|
||||
|
||||
VTKM_CONT
|
||||
void Shrink(vtkm::Id numValues) { this->Storage->Shrink(numValues); }
|
||||
|
||||
|
||||
VTKM_CONT
|
||||
void ReleaseResources()
|
||||
{
|
||||
// no-op
|
||||
}
|
||||
|
||||
private:
|
||||
StorageType* Storage;
|
||||
};
|
||||
|
||||
} // namespace internal
|
||||
|
||||
template <typename T, typename DecoratorImplT, typename... ArrayTs>
|
||||
VTKM_ARRAY_HANDLE_NEW_STYLE(
|
||||
T,
|
||||
VTKM_PASS_COMMAS(internal::StorageTagDecorator<DecoratorImplT, ArrayTs...>));
|
||||
|
||||
/// \brief A fancy ArrayHandle that can be used to modify the results from one
|
||||
/// or more source ArrayHandle.
|
||||
///
|
||||
@ -872,19 +655,11 @@ private:
|
||||
/// // number of values.
|
||||
/// template <typename Array1Type, typename Array2Type>
|
||||
/// VTKM_CONT
|
||||
/// void AllocateSourceArrays(vtkm::Id size, Array1Type array1, Array2Type array2) const;
|
||||
///
|
||||
/// // Given a set of ArrayHandles and a size, implement what should happen to
|
||||
/// // the source ArrayHandles when Shrink() is called on the decorator handle.
|
||||
/// //
|
||||
/// // ShrinkSourceArrays is optional; if not provided, the
|
||||
/// // ArrayHandleDecorator will throw if its Shrink 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
|
||||
/// void ShrinkSourceArrays(vtkm::Id size, Array1Type array1, Array2Type array2) const;
|
||||
/// void AllocateSourceArrays(vtkm::Id size,
|
||||
/// vtkm::CopyFlag preserve,
|
||||
/// vtkm::cont::Token& token,
|
||||
/// Array1Type array1,
|
||||
/// Array2Type array2) const;
|
||||
///
|
||||
/// };
|
||||
/// ```
|
||||
@ -912,7 +687,7 @@ public:
|
||||
ArrayHandleDecorator(vtkm::Id numValues,
|
||||
const typename std::decay<DecoratorImplT>::type& impl,
|
||||
const typename std::decay<ArrayTs>::type&... arrays)
|
||||
: Superclass{ StorageType{ impl, vtkm::MakeTuple(arrays...), numValues } }
|
||||
: Superclass{ StorageType::CreateBuffers(impl, numValues, arrays...) }
|
||||
{
|
||||
}
|
||||
};
|
||||
|
@ -110,6 +110,7 @@ set(headers
|
||||
Serialization.h
|
||||
Storage.h
|
||||
StorageExtrude.h
|
||||
StorageImplicit.h # Deprecated, rolled into ArrayHandleImplicit.h
|
||||
StorageList.h
|
||||
StorageListTag.h
|
||||
Timer.h
|
||||
|
29
vtkm/cont/StorageImplicit.h
Normal file
29
vtkm/cont/StorageImplicit.h
Normal file
@ -0,0 +1,29 @@
|
||||
//============================================================================
|
||||
// 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_cont_StorageImplicit_h
|
||||
#define vtk_m_cont_StorageImplicit_h
|
||||
|
||||
#include <vtkm/Deprecated.h>
|
||||
#include <vtkm/cont/ArrayHandleImplicit.h>
|
||||
|
||||
namespace vtkm
|
||||
{
|
||||
|
||||
VTKM_DEPRECATED(1.6, "Use ArrayHandleImplicit.h instead of StorageImplicit.h.")
|
||||
inline void StorageImplicit_h_deprecated() {}
|
||||
|
||||
inline void ActivateStorageImplicit_h_deprecated_warning()
|
||||
{
|
||||
StorageImplicit_h_deprecated();
|
||||
}
|
||||
|
||||
} // namespace vtkm
|
||||
|
||||
#endif //vtk_m_cont_StorageImplicit_h
|
@ -261,17 +261,14 @@ struct DecoratorTests
|
||||
|
||||
// Resize methods:
|
||||
template <typename Array1T, typename Array2T>
|
||||
VTKM_CONT void AllocateSourceArrays(vtkm::Id numVals, Array1T&& array1, Array2T&& array2) const
|
||||
VTKM_CONT void AllocateSourceArrays(vtkm::Id numVals,
|
||||
vtkm::CopyFlag preserve,
|
||||
vtkm::cont::Token& token,
|
||||
Array1T&& array1,
|
||||
Array2T&& array2) const
|
||||
{
|
||||
array1.Allocate(numVals);
|
||||
array2.Allocate(numVals);
|
||||
}
|
||||
|
||||
template <typename Array1T, typename Array2T>
|
||||
VTKM_CONT void ShrinkSourceArrays(vtkm::Id numVals, Array1T&& array1, Array2T&& array2) const
|
||||
{
|
||||
array1.Shrink(numVals);
|
||||
array2.Shrink(numVals);
|
||||
array1.Allocate(numVals, preserve, token);
|
||||
array2.Allocate(numVals, preserve, token);
|
||||
}
|
||||
};
|
||||
|
||||
@ -521,7 +518,7 @@ struct DecoratorTests
|
||||
}
|
||||
};
|
||||
|
||||
// ArrayHandleDecorator that implements AllocateSourceArrays and ShrinkSourceArrays, thus allowing
|
||||
// ArrayHandleDecorator that implements AllocateSourceArrays, thus allowing
|
||||
// it to be resized.
|
||||
struct ResizableDecorImpl
|
||||
{
|
||||
@ -538,29 +535,32 @@ struct ResizableDecorImpl
|
||||
}
|
||||
|
||||
template <typename Array1T, typename Array2T>
|
||||
void ShrinkSourceArrays(vtkm::Id newSize, Array1T& a1, Array2T& a2) const
|
||||
void AllocateSourceArrays(vtkm::Id newSize,
|
||||
vtkm::CopyFlag preserve,
|
||||
vtkm::cont::Token& token,
|
||||
Array1T& a1,
|
||||
Array2T& a2) const
|
||||
{
|
||||
VTKM_IS_ARRAY_HANDLE(Array1T);
|
||||
VTKM_IS_ARRAY_HANDLE(Array2T);
|
||||
|
||||
// Resize each to 2*newSize:
|
||||
a1.Shrink(2 * newSize);
|
||||
a2.Shrink(2 * newSize);
|
||||
}
|
||||
|
||||
template <typename Array1T, typename Array2T>
|
||||
void AllocateSourceArrays(vtkm::Id newSize, Array1T& a1, Array2T& a2) const
|
||||
{
|
||||
VTKM_IS_ARRAY_HANDLE(Array1T);
|
||||
VTKM_IS_ARRAY_HANDLE(Array2T);
|
||||
|
||||
// Resize each to 3*newSize:
|
||||
a1.Allocate(3 * newSize);
|
||||
a2.Allocate(3 * newSize);
|
||||
// Resize differently based on preserve to verify the flag is correct.
|
||||
if (preserve == vtkm::CopyFlag::Off)
|
||||
{
|
||||
// Resize each to 3*newSize:
|
||||
a1.Allocate(3 * newSize, preserve, token);
|
||||
a2.Allocate(3 * newSize, preserve, token);
|
||||
}
|
||||
else
|
||||
{
|
||||
// Resize each to 2*newSize:
|
||||
a1.Shrink(2 * newSize);
|
||||
a2.Shrink(2 * newSize);
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
// ArrayHandleDecorator that implements AllocateSourceArrays and ShrinkSourceArrays, thus allowing
|
||||
// ArrayHandleDecorator that does not implement AllocateSourceArrays, thus not allowing
|
||||
// it to be resized.
|
||||
struct NonResizableDecorImpl
|
||||
{
|
||||
@ -591,7 +591,7 @@ void ResizeTest()
|
||||
VTKM_TEST_ASSERT(a1.GetNumberOfValues() == 30);
|
||||
VTKM_TEST_ASSERT(a2.GetNumberOfValues() == 30);
|
||||
VTKM_TEST_ASSERT(decor.GetNumberOfValues() == 10);
|
||||
decor.Shrink(3); // Should resize a1&a2 to have 6 values:
|
||||
decor.Allocate(3, vtkm::CopyFlag::On); // Should resize a1&a2 to have 6 values:
|
||||
VTKM_TEST_ASSERT(a1.GetNumberOfValues() == 6);
|
||||
VTKM_TEST_ASSERT(a2.GetNumberOfValues() == 6);
|
||||
VTKM_TEST_ASSERT(decor.GetNumberOfValues() == 3);
|
||||
|
@ -24,7 +24,7 @@ namespace filter
|
||||
|
||||
template VTKM_FILTER_EXTRA_EXPORT vtkm::cont::DataSet ClipWithField::DoExecute(
|
||||
const vtkm::cont::DataSet&,
|
||||
const vtkm::cont::ArrayHandle<vtkm::Int8>&,
|
||||
const vtkm::cont::ArrayHandle<char>&,
|
||||
const vtkm::filter::FieldMetadata&,
|
||||
vtkm::filter::PolicyBase<vtkm::filter::PolicyDefault>);
|
||||
|
||||
@ -32,7 +32,7 @@ template VTKM_FILTER_EXTRA_EXPORT vtkm::cont::DataSet ClipWithField::DoExecute(
|
||||
VTKM_DEPRECATED_SUPPRESS_BEGIN
|
||||
template VTKM_FILTER_EXTRA_EXPORT vtkm::cont::DataSet ClipWithField::DoExecute(
|
||||
const vtkm::cont::DataSet&,
|
||||
const vtkm::cont::ArrayHandle<vtkm::Int8, vtkm::cont::StorageTagVirtual>&,
|
||||
const vtkm::cont::ArrayHandle<char, vtkm::cont::StorageTagVirtual>&,
|
||||
const vtkm::filter::FieldMetadata&,
|
||||
vtkm::filter::PolicyBase<vtkm::filter::PolicyDefault>);
|
||||
VTKM_DEPRECATED_SUPPRESS_END
|
||||
@ -40,7 +40,7 @@ VTKM_DEPRECATED_SUPPRESS_END
|
||||
|
||||
template VTKM_FILTER_EXTRA_EXPORT vtkm::cont::DataSet ClipWithField::DoExecute(
|
||||
const vtkm::cont::DataSet&,
|
||||
const vtkm::cont::ArrayHandle<vtkm::Int16>&,
|
||||
const vtkm::cont::ArrayHandle<signed char>&,
|
||||
const vtkm::filter::FieldMetadata&,
|
||||
vtkm::filter::PolicyBase<vtkm::filter::PolicyDefault>);
|
||||
|
||||
@ -48,7 +48,7 @@ template VTKM_FILTER_EXTRA_EXPORT vtkm::cont::DataSet ClipWithField::DoExecute(
|
||||
VTKM_DEPRECATED_SUPPRESS_BEGIN
|
||||
template VTKM_FILTER_EXTRA_EXPORT vtkm::cont::DataSet ClipWithField::DoExecute(
|
||||
const vtkm::cont::DataSet&,
|
||||
const vtkm::cont::ArrayHandle<vtkm::Int16, vtkm::cont::StorageTagVirtual>&,
|
||||
const vtkm::cont::ArrayHandle<signed char, vtkm::cont::StorageTagVirtual>&,
|
||||
const vtkm::filter::FieldMetadata&,
|
||||
vtkm::filter::PolicyBase<vtkm::filter::PolicyDefault>);
|
||||
VTKM_DEPRECATED_SUPPRESS_END
|
||||
@ -56,7 +56,7 @@ VTKM_DEPRECATED_SUPPRESS_END
|
||||
|
||||
template VTKM_FILTER_EXTRA_EXPORT vtkm::cont::DataSet ClipWithField::DoExecute(
|
||||
const vtkm::cont::DataSet&,
|
||||
const vtkm::cont::ArrayHandle<vtkm::Int32>&,
|
||||
const vtkm::cont::ArrayHandle<short>&,
|
||||
const vtkm::filter::FieldMetadata&,
|
||||
vtkm::filter::PolicyBase<vtkm::filter::PolicyDefault>);
|
||||
|
||||
@ -64,7 +64,7 @@ template VTKM_FILTER_EXTRA_EXPORT vtkm::cont::DataSet ClipWithField::DoExecute(
|
||||
VTKM_DEPRECATED_SUPPRESS_BEGIN
|
||||
template VTKM_FILTER_EXTRA_EXPORT vtkm::cont::DataSet ClipWithField::DoExecute(
|
||||
const vtkm::cont::DataSet&,
|
||||
const vtkm::cont::ArrayHandle<vtkm::Int32, vtkm::cont::StorageTagVirtual>&,
|
||||
const vtkm::cont::ArrayHandle<short, vtkm::cont::StorageTagVirtual>&,
|
||||
const vtkm::filter::FieldMetadata&,
|
||||
vtkm::filter::PolicyBase<vtkm::filter::PolicyDefault>);
|
||||
VTKM_DEPRECATED_SUPPRESS_END
|
||||
@ -72,7 +72,7 @@ VTKM_DEPRECATED_SUPPRESS_END
|
||||
|
||||
template VTKM_FILTER_EXTRA_EXPORT vtkm::cont::DataSet ClipWithField::DoExecute(
|
||||
const vtkm::cont::DataSet&,
|
||||
const vtkm::cont::ArrayHandle<vtkm::Int64>&,
|
||||
const vtkm::cont::ArrayHandle<int>&,
|
||||
const vtkm::filter::FieldMetadata&,
|
||||
vtkm::filter::PolicyBase<vtkm::filter::PolicyDefault>);
|
||||
|
||||
@ -80,7 +80,39 @@ template VTKM_FILTER_EXTRA_EXPORT vtkm::cont::DataSet ClipWithField::DoExecute(
|
||||
VTKM_DEPRECATED_SUPPRESS_BEGIN
|
||||
template VTKM_FILTER_EXTRA_EXPORT vtkm::cont::DataSet ClipWithField::DoExecute(
|
||||
const vtkm::cont::DataSet&,
|
||||
const vtkm::cont::ArrayHandle<vtkm::Int64, vtkm::cont::StorageTagVirtual>&,
|
||||
const vtkm::cont::ArrayHandle<int, vtkm::cont::StorageTagVirtual>&,
|
||||
const vtkm::filter::FieldMetadata&,
|
||||
vtkm::filter::PolicyBase<vtkm::filter::PolicyDefault>);
|
||||
VTKM_DEPRECATED_SUPPRESS_END
|
||||
#endif
|
||||
|
||||
template VTKM_FILTER_EXTRA_EXPORT vtkm::cont::DataSet ClipWithField::DoExecute(
|
||||
const vtkm::cont::DataSet&,
|
||||
const vtkm::cont::ArrayHandle<long>&,
|
||||
const vtkm::filter::FieldMetadata&,
|
||||
vtkm::filter::PolicyBase<vtkm::filter::PolicyDefault>);
|
||||
|
||||
#ifndef VTKM_NO_DEPRECATED_VIRTUAL
|
||||
VTKM_DEPRECATED_SUPPRESS_BEGIN
|
||||
template VTKM_FILTER_EXTRA_EXPORT vtkm::cont::DataSet ClipWithField::DoExecute(
|
||||
const vtkm::cont::DataSet&,
|
||||
const vtkm::cont::ArrayHandle<long, vtkm::cont::StorageTagVirtual>&,
|
||||
const vtkm::filter::FieldMetadata&,
|
||||
vtkm::filter::PolicyBase<vtkm::filter::PolicyDefault>);
|
||||
VTKM_DEPRECATED_SUPPRESS_END
|
||||
#endif
|
||||
|
||||
template VTKM_FILTER_EXTRA_EXPORT vtkm::cont::DataSet ClipWithField::DoExecute(
|
||||
const vtkm::cont::DataSet&,
|
||||
const vtkm::cont::ArrayHandle<long long>&,
|
||||
const vtkm::filter::FieldMetadata&,
|
||||
vtkm::filter::PolicyBase<vtkm::filter::PolicyDefault>);
|
||||
|
||||
#ifndef VTKM_NO_DEPRECATED_VIRTUAL
|
||||
VTKM_DEPRECATED_SUPPRESS_BEGIN
|
||||
template VTKM_FILTER_EXTRA_EXPORT vtkm::cont::DataSet ClipWithField::DoExecute(
|
||||
const vtkm::cont::DataSet&,
|
||||
const vtkm::cont::ArrayHandle<long long, vtkm::cont::StorageTagVirtual>&,
|
||||
const vtkm::filter::FieldMetadata&,
|
||||
vtkm::filter::PolicyBase<vtkm::filter::PolicyDefault>);
|
||||
VTKM_DEPRECATED_SUPPRESS_END
|
||||
|
@ -36,7 +36,7 @@ namespace filter
|
||||
|
||||
$py(
|
||||
# These values are taken from vtkm/TypeList.h
|
||||
types = [ "vtkm::Int8", "vtkm::Int16", "vtkm::Int32", "vtkm::Int64"]
|
||||
types = [ "char", "signed char", "short", "int", "long", "long long" ]
|
||||
)\
|
||||
\
|
||||
$for(TYPE in types)\
|
||||
|
@ -24,7 +24,7 @@ namespace filter
|
||||
|
||||
template VTKM_FILTER_EXTRA_EXPORT vtkm::cont::DataSet ClipWithField::DoExecute(
|
||||
const vtkm::cont::DataSet&,
|
||||
const vtkm::cont::ArrayHandle<vtkm::UInt8>&,
|
||||
const vtkm::cont::ArrayHandle<unsigned char>&,
|
||||
const vtkm::filter::FieldMetadata&,
|
||||
vtkm::filter::PolicyBase<vtkm::filter::PolicyDefault>);
|
||||
|
||||
@ -32,7 +32,7 @@ template VTKM_FILTER_EXTRA_EXPORT vtkm::cont::DataSet ClipWithField::DoExecute(
|
||||
VTKM_DEPRECATED_SUPPRESS_BEGIN
|
||||
template VTKM_FILTER_EXTRA_EXPORT vtkm::cont::DataSet ClipWithField::DoExecute(
|
||||
const vtkm::cont::DataSet&,
|
||||
const vtkm::cont::ArrayHandle<vtkm::UInt8, vtkm::cont::StorageTagVirtual>&,
|
||||
const vtkm::cont::ArrayHandle<unsigned char, vtkm::cont::StorageTagVirtual>&,
|
||||
const vtkm::filter::FieldMetadata&,
|
||||
vtkm::filter::PolicyBase<vtkm::filter::PolicyDefault>);
|
||||
VTKM_DEPRECATED_SUPPRESS_END
|
||||
@ -40,7 +40,7 @@ VTKM_DEPRECATED_SUPPRESS_END
|
||||
|
||||
template VTKM_FILTER_EXTRA_EXPORT vtkm::cont::DataSet ClipWithField::DoExecute(
|
||||
const vtkm::cont::DataSet&,
|
||||
const vtkm::cont::ArrayHandle<vtkm::UInt16>&,
|
||||
const vtkm::cont::ArrayHandle<unsigned short>&,
|
||||
const vtkm::filter::FieldMetadata&,
|
||||
vtkm::filter::PolicyBase<vtkm::filter::PolicyDefault>);
|
||||
|
||||
@ -48,7 +48,7 @@ template VTKM_FILTER_EXTRA_EXPORT vtkm::cont::DataSet ClipWithField::DoExecute(
|
||||
VTKM_DEPRECATED_SUPPRESS_BEGIN
|
||||
template VTKM_FILTER_EXTRA_EXPORT vtkm::cont::DataSet ClipWithField::DoExecute(
|
||||
const vtkm::cont::DataSet&,
|
||||
const vtkm::cont::ArrayHandle<vtkm::UInt16, vtkm::cont::StorageTagVirtual>&,
|
||||
const vtkm::cont::ArrayHandle<unsigned short, vtkm::cont::StorageTagVirtual>&,
|
||||
const vtkm::filter::FieldMetadata&,
|
||||
vtkm::filter::PolicyBase<vtkm::filter::PolicyDefault>);
|
||||
VTKM_DEPRECATED_SUPPRESS_END
|
||||
@ -56,7 +56,7 @@ VTKM_DEPRECATED_SUPPRESS_END
|
||||
|
||||
template VTKM_FILTER_EXTRA_EXPORT vtkm::cont::DataSet ClipWithField::DoExecute(
|
||||
const vtkm::cont::DataSet&,
|
||||
const vtkm::cont::ArrayHandle<vtkm::UInt32>&,
|
||||
const vtkm::cont::ArrayHandle<unsigned int>&,
|
||||
const vtkm::filter::FieldMetadata&,
|
||||
vtkm::filter::PolicyBase<vtkm::filter::PolicyDefault>);
|
||||
|
||||
@ -64,7 +64,7 @@ template VTKM_FILTER_EXTRA_EXPORT vtkm::cont::DataSet ClipWithField::DoExecute(
|
||||
VTKM_DEPRECATED_SUPPRESS_BEGIN
|
||||
template VTKM_FILTER_EXTRA_EXPORT vtkm::cont::DataSet ClipWithField::DoExecute(
|
||||
const vtkm::cont::DataSet&,
|
||||
const vtkm::cont::ArrayHandle<vtkm::UInt32, vtkm::cont::StorageTagVirtual>&,
|
||||
const vtkm::cont::ArrayHandle<unsigned int, vtkm::cont::StorageTagVirtual>&,
|
||||
const vtkm::filter::FieldMetadata&,
|
||||
vtkm::filter::PolicyBase<vtkm::filter::PolicyDefault>);
|
||||
VTKM_DEPRECATED_SUPPRESS_END
|
||||
@ -72,7 +72,7 @@ VTKM_DEPRECATED_SUPPRESS_END
|
||||
|
||||
template VTKM_FILTER_EXTRA_EXPORT vtkm::cont::DataSet ClipWithField::DoExecute(
|
||||
const vtkm::cont::DataSet&,
|
||||
const vtkm::cont::ArrayHandle<vtkm::UInt64>&,
|
||||
const vtkm::cont::ArrayHandle<unsigned long>&,
|
||||
const vtkm::filter::FieldMetadata&,
|
||||
vtkm::filter::PolicyBase<vtkm::filter::PolicyDefault>);
|
||||
|
||||
@ -80,7 +80,23 @@ template VTKM_FILTER_EXTRA_EXPORT vtkm::cont::DataSet ClipWithField::DoExecute(
|
||||
VTKM_DEPRECATED_SUPPRESS_BEGIN
|
||||
template VTKM_FILTER_EXTRA_EXPORT vtkm::cont::DataSet ClipWithField::DoExecute(
|
||||
const vtkm::cont::DataSet&,
|
||||
const vtkm::cont::ArrayHandle<vtkm::UInt64, vtkm::cont::StorageTagVirtual>&,
|
||||
const vtkm::cont::ArrayHandle<unsigned long, vtkm::cont::StorageTagVirtual>&,
|
||||
const vtkm::filter::FieldMetadata&,
|
||||
vtkm::filter::PolicyBase<vtkm::filter::PolicyDefault>);
|
||||
VTKM_DEPRECATED_SUPPRESS_END
|
||||
#endif
|
||||
|
||||
template VTKM_FILTER_EXTRA_EXPORT vtkm::cont::DataSet ClipWithField::DoExecute(
|
||||
const vtkm::cont::DataSet&,
|
||||
const vtkm::cont::ArrayHandle<unsigned long long>&,
|
||||
const vtkm::filter::FieldMetadata&,
|
||||
vtkm::filter::PolicyBase<vtkm::filter::PolicyDefault>);
|
||||
|
||||
#ifndef VTKM_NO_DEPRECATED_VIRTUAL
|
||||
VTKM_DEPRECATED_SUPPRESS_BEGIN
|
||||
template VTKM_FILTER_EXTRA_EXPORT vtkm::cont::DataSet ClipWithField::DoExecute(
|
||||
const vtkm::cont::DataSet&,
|
||||
const vtkm::cont::ArrayHandle<unsigned long long, vtkm::cont::StorageTagVirtual>&,
|
||||
const vtkm::filter::FieldMetadata&,
|
||||
vtkm::filter::PolicyBase<vtkm::filter::PolicyDefault>);
|
||||
VTKM_DEPRECATED_SUPPRESS_END
|
||||
|
@ -36,7 +36,7 @@ namespace filter
|
||||
|
||||
$py(
|
||||
# These values are taken from vtkm/TypeList.h
|
||||
types = ["vtkm::UInt8", "vtkm::UInt16", "vtkm::UInt32", "vtkm::UInt64"]
|
||||
types = ["unsigned char", "unsigned short", "unsigned int", "unsigned long", "unsigned long long"]
|
||||
)\
|
||||
\
|
||||
$for(TYPE in types)\
|
||||
|
Loading…
Reference in New Issue
Block a user