Shuenhoy/vtk-m
1
0
Fork 0
mirror of https://gitlab.kitware.com/vtk/vtk-m synced 2024-10-08 11:29:02 +00:00
Code Issues 2 Actions Packages Projects Releases Wiki Activity

Support using Token calling PrepareForExecution in ExecutionObject

Browse Source 
The old version of ExecutionObject (that only takes a device) is still
supported, but you will get a deprecated warning if that is what is
defined.

Supporing this also included sending vtkm::cont::Token through the
vtkm::cont::arg::Transport mechanism, which was a change that propogated
through a lot of code.
This commit is contained in:
Kenneth Moreland 2020-01-18 23:36:14 -07:00
parent ef3f544a67
commit 76ce9c87f0
64 changed files with 832 additions and 410 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

75
vtkm/cont/Algorithm.h
View File

@ -14,6 +14,7 @@
#include <vtkm/cont/DeviceAdapterTag.h>
#include <vtkm/cont/ExecutionObjectBase.h>
#include <vtkm/cont/Token.h>
#include <vtkm/cont/TryExecute.h>
#include <vtkm/cont/internal/ArrayManagerExecution.h>
@ -26,15 +27,16 @@ namespace cont
namespace detail
{
template <typename Device, typename T>
inline auto DoPrepareArgForExec(T&& object, std::true_type)
inline auto DoPrepareArgForExec(T&& object, vtkm::cont::Token& token, std::true_type)
-> decltype(std::declval<T>().PrepareForExecution(Device()))
{
VTKM_IS_EXECUTION_OBJECT(T);
return vtkm::cont::internal::CallPrepareForExecution(object, Device{}, token);
return object.PrepareForExecution(Device{});
}
template <typename Device, typename T>
inline T&& DoPrepareArgForExec(T&& object, std::false_type)
inline T&& DoPrepareArgForExec(T&& object, vtkm::cont::Token&, std::false_type)
{
static_assert(!vtkm::cont::internal::IsExecutionObjectBase<T>::value,
"Internal error: failed to detect execution object.");
@ -42,12 +44,13 @@ inline T&& DoPrepareArgForExec(T&& object, std::false_type)
}
template <typename Device, typename T>
auto PrepareArgForExec(T&& object)
auto PrepareArgForExec(T&& object, vtkm::cont::Token& token)
-> decltype(DoPrepareArgForExec<Device>(std::forward<T>(object),
token,
vtkm::cont::internal::IsExecutionObjectBase<T>{}))
{
return DoPrepareArgForExec<Device>(std::forward<T>(object),
vtkm::cont::internal::IsExecutionObjectBase<T>{});
return DoPrepareArgForExec<Device>(
std::forward<T>(object), token, vtkm::cont::internal::IsExecutionObjectBase<T>{});
}
struct BitFieldToUnorderedSetFunctor
@ -58,8 +61,9 @@ struct BitFieldToUnorderedSetFunctor
VTKM_CONT bool operator()(Device, Args&&... args)
{
VTKM_IS_DEVICE_ADAPTER_TAG(Device);
vtkm::cont::Token token;
this->Result = vtkm::cont::DeviceAdapterAlgorithm<Device>::BitFieldToUnorderedSet(
PrepareArgForExec<Device>(std::forward<Args>(args))...);
PrepareArgForExec<Device>(std::forward<Args>(args), token)...);
return true;
}
};
@ -70,8 +74,9 @@ struct CopyFunctor
VTKM_CONT bool operator()(Device, Args&&... args) const
{
VTKM_IS_DEVICE_ADAPTER_TAG(Device);
vtkm::cont::Token token;
vtkm::cont::DeviceAdapterAlgorithm<Device>::Copy(
PrepareArgForExec<Device>(std::forward<Args>(args))...);
PrepareArgForExec<Device>(std::forward<Args>(args), token)...);
return true;
}
};
@ -83,8 +88,9 @@ struct CopyIfFunctor
VTKM_CONT bool operator()(Device, Args&&... args) const
{
VTKM_IS_DEVICE_ADAPTER_TAG(Device);
vtkm::cont::Token token;
vtkm::cont::DeviceAdapterAlgorithm<Device>::CopyIf(
PrepareArgForExec<Device>(std::forward<Args>(args))...);
PrepareArgForExec<Device>(std::forward<Args>(args), token)...);
return true;
}
};
@ -102,8 +108,9 @@ struct CopySubRangeFunctor
VTKM_CONT bool operator()(Device, Args&&... args)
{
VTKM_IS_DEVICE_ADAPTER_TAG(Device);
vtkm::cont::Token token;
valid = vtkm::cont::DeviceAdapterAlgorithm<Device>::CopySubRange(
PrepareArgForExec<Device>(std::forward<Args>(args))...);
PrepareArgForExec<Device>(std::forward<Args>(args), token)...);
return true;
}
};
@ -115,8 +122,10 @@ struct CountSetBitsFunctor
template <typename Device, typename... Args>
VTKM_CONT bool operator()(Device, Args&&... args)
{
VTKM_IS_DEVICE_ADAPTER_TAG(Device);
vtkm::cont::Token token;
this->PopCount = vtkm::cont::DeviceAdapterAlgorithm<Device>::CountSetBits(
PrepareArgForExec<Device>(std::forward<Args>(args))...);
PrepareArgForExec<Device>(std::forward<Args>(args), token)...);
return true;
}
};
@ -126,8 +135,10 @@ struct FillFunctor
template <typename Device, typename... Args>
VTKM_CONT bool operator()(Device, Args&&... args)
{
VTKM_IS_DEVICE_ADAPTER_TAG(Device);
vtkm::cont::Token token;
vtkm::cont::DeviceAdapterAlgorithm<Device>::Fill(
PrepareArgForExec<Device>(std::forward<Args>(args))...);
PrepareArgForExec<Device>(std::forward<Args>(args), token)...);
return true;
}
};
@ -139,8 +150,9 @@ struct LowerBoundsFunctor
VTKM_CONT bool operator()(Device, Args&&... args) const
{
VTKM_IS_DEVICE_ADAPTER_TAG(Device);
vtkm::cont::Token token;
vtkm::cont::DeviceAdapterAlgorithm<Device>::LowerBounds(
PrepareArgForExec<Device>(std::forward<Args>(args))...);
PrepareArgForExec<Device>(std::forward<Args>(args), token)...);
return true;
}
};
@ -159,8 +171,9 @@ struct ReduceFunctor
VTKM_CONT bool operator()(Device, Args&&... args)
{
VTKM_IS_DEVICE_ADAPTER_TAG(Device);
vtkm::cont::Token token;
result = vtkm::cont::DeviceAdapterAlgorithm<Device>::Reduce(
PrepareArgForExec<Device>(std::forward<Args>(args))...);
PrepareArgForExec<Device>(std::forward<Args>(args), token)...);
return true;
}
};
@ -171,8 +184,9 @@ struct ReduceByKeyFunctor
VTKM_CONT bool operator()(Device, Args&&... args) const
{
VTKM_IS_DEVICE_ADAPTER_TAG(Device);
vtkm::cont::Token token;
vtkm::cont::DeviceAdapterAlgorithm<Device>::ReduceByKey(
PrepareArgForExec<Device>(std::forward<Args>(args))...);
PrepareArgForExec<Device>(std::forward<Args>(args), token)...);
return true;
}
};
@ -191,8 +205,9 @@ struct ScanInclusiveResultFunctor
VTKM_CONT bool operator()(Device, Args&&... args)
{
VTKM_IS_DEVICE_ADAPTER_TAG(Device);
vtkm::cont::Token token;
result = vtkm::cont::DeviceAdapterAlgorithm<Device>::ScanInclusive(
PrepareArgForExec<Device>(std::forward<Args>(args))...);
PrepareArgForExec<Device>(std::forward<Args>(args), token)...);
return true;
}
};
@ -275,8 +290,9 @@ struct ScanInclusiveByKeyFunctor
VTKM_CONT bool operator()(Device, Args&&... args) const
{
VTKM_IS_DEVICE_ADAPTER_TAG(Device);
vtkm::cont::Token token;
vtkm::cont::DeviceAdapterAlgorithm<Device>::ScanInclusiveByKey(
PrepareArgForExec<Device>(std::forward<Args>(args))...);
PrepareArgForExec<Device>(std::forward<Args>(args), token)...);
return true;
}
};
@ -295,8 +311,9 @@ struct ScanExclusiveFunctor
VTKM_CONT bool operator()(Device, Args&&... args)
{
VTKM_IS_DEVICE_ADAPTER_TAG(Device);
vtkm::cont::Token token;
result = vtkm::cont::DeviceAdapterAlgorithm<Device>::ScanExclusive(
PrepareArgForExec<Device>(std::forward<Args>(args))...);
PrepareArgForExec<Device>(std::forward<Args>(args), token)...);
return true;
}
};
@ -309,8 +326,9 @@ struct ScanExclusiveByKeyFunctor
VTKM_CONT bool operator()(Device, Args&&... args) const
{
VTKM_IS_DEVICE_ADAPTER_TAG(Device);
vtkm::cont::Token token;
vtkm::cont::DeviceAdapterAlgorithm<Device>::ScanExclusiveByKey(
PrepareArgForExec<Device>(std::forward<Args>(args))...);
PrepareArgForExec<Device>(std::forward<Args>(args), token)...);
return true;
}
};
@ -322,8 +340,9 @@ struct ScanExtendedFunctor
VTKM_CONT bool operator()(Device, Args&&... args)
{
VTKM_IS_DEVICE_ADAPTER_TAG(Device);
vtkm::cont::Token token;
vtkm::cont::DeviceAdapterAlgorithm<Device>::ScanExtended(
PrepareArgForExec<Device>(std::forward<Args>(args))...);
PrepareArgForExec<Device>(std::forward<Args>(args), token)...);
return true;
}
};
@ -334,8 +353,9 @@ struct ScheduleFunctor
VTKM_CONT bool operator()(Device, Args&&... args)
{
VTKM_IS_DEVICE_ADAPTER_TAG(Device);
vtkm::cont::Token token;
vtkm::cont::DeviceAdapterAlgorithm<Device>::Schedule(
PrepareArgForExec<Device>(std::forward<Args>(args))...);
PrepareArgForExec<Device>(std::forward<Args>(args), token)...);
return true;
}
};
@ -346,8 +366,9 @@ struct SortFunctor
VTKM_CONT bool operator()(Device, Args&&... args) const
{
VTKM_IS_DEVICE_ADAPTER_TAG(Device);
vtkm::cont::Token token;
vtkm::cont::DeviceAdapterAlgorithm<Device>::Sort(
PrepareArgForExec<Device>(std::forward<Args>(args))...);
PrepareArgForExec<Device>(std::forward<Args>(args), token)...);
return true;
}
};
@ -358,8 +379,9 @@ struct SortByKeyFunctor
VTKM_CONT bool operator()(Device, Args&&... args) const
{
VTKM_IS_DEVICE_ADAPTER_TAG(Device);
vtkm::cont::Token token;
vtkm::cont::DeviceAdapterAlgorithm<Device>::SortByKey(
PrepareArgForExec<Device>(std::forward<Args>(args))...);
PrepareArgForExec<Device>(std::forward<Args>(args), token)...);
return true;
}
};
@ -381,8 +403,9 @@ struct TransformFunctor
VTKM_CONT bool operator()(Device, Args&&... args) const
{
VTKM_IS_DEVICE_ADAPTER_TAG(Device);
vtkm::cont::Token token;
vtkm::cont::DeviceAdapterAlgorithm<Device>::Transform(
PrepareArgForExec<Device>(std::forward<Args>(args))...);
PrepareArgForExec<Device>(std::forward<Args>(args), token)...);
return true;
}
};
@ -393,8 +416,9 @@ struct UniqueFunctor
VTKM_CONT bool operator()(Device, Args&&... args) const
{
VTKM_IS_DEVICE_ADAPTER_TAG(Device);
vtkm::cont::Token token;
vtkm::cont::DeviceAdapterAlgorithm<Device>::Unique(
PrepareArgForExec<Device>(std::forward<Args>(args))...);
PrepareArgForExec<Device>(std::forward<Args>(args), token)...);
return true;
}
};
@ -405,8 +429,9 @@ struct UpperBoundsFunctor
VTKM_CONT bool operator()(Device, Args&&... args) const
{
VTKM_IS_DEVICE_ADAPTER_TAG(Device);
vtkm::cont::Token token;
vtkm::cont::DeviceAdapterAlgorithm<Device>::UpperBounds(
PrepareArgForExec<Device>(std::forward<Args>(args))...);
PrepareArgForExec<Device>(std::forward<Args>(args), token)...);
return true;
}
};

7
vtkm/cont/ArrayHandle.hxx
View File

@ -235,7 +235,7 @@ ArrayHandle<T, S>::PrepareForInput(DeviceAdapterTag device, vtkm::cont::Token& t
this->PrepareForDevice(lock, device);
auto portal = this->Internals->GetExecutionArray(lock)->PrepareForInput(
!this->Internals->IsExecutionArrayValid(lock), device);
!this->Internals->IsExecutionArrayValid(lock), device, token);
this->Internals->SetExecutionArrayValid(lock, true);
@ -263,7 +263,8 @@ ArrayHandle<T, S>::PrepareForOutput(vtkm::Id numberOfValues,
this->Internals->SetControlArrayValid(lock, false);
this->PrepareForDevice(lock, device);
auto portal = this->Internals->GetExecutionArray(lock)->PrepareForOutput(numberOfValues, device);
auto portal =
this->Internals->GetExecutionArray(lock)->PrepareForOutput(numberOfValues, device, token);
// We are assuming that the calling code will fill the array using the
// iterators we are returning, so go ahead and mark the execution array as
@ -302,7 +303,7 @@ ArrayHandle<T, S>::PrepareForInPlace(DeviceAdapterTag device, vtkm::cont::Token&
this->PrepareForDevice(lock, device);
auto portal = this->Internals->GetExecutionArray(lock)->PrepareForInPlace(
!this->Internals->IsExecutionArrayValid(lock), device);
!this->Internals->IsExecutionArrayValid(lock), device, token);
this->Internals->SetExecutionArrayValid(lock, true);

12
vtkm/cont/ArrayHandleBitField.h
View File

@ -129,21 +129,21 @@ public:
vtkm::Id GetNumberOfValues() const { return this->Data.GetNumberOfBits(); }
VTKM_CONT
PortalConstExecution PrepareForInput(bool vtkmNotUsed(updateData))
PortalConstExecution PrepareForInput(bool vtkmNotUsed(updateData), vtkm::cont::Token& token)
{
return PortalConstExecution{ this->Data.PrepareForInput(Device{}) };
return PortalConstExecution{ this->Data.PrepareForInput(Device{}, token) };
}
VTKM_CONT
PortalExecution PrepareForInPlace(bool vtkmNotUsed(updateData))
PortalExecution PrepareForInPlace(bool vtkmNotUsed(updateData), vtkm::cont::Token& token)
{
return PortalExecution{ this->Data.PrepareForInPlace(Device{}) };
return PortalExecution{ this->Data.PrepareForInPlace(Device{}, token) };
}
VTKM_CONT
PortalExecution PrepareForOutput(vtkm::Id numberOfValues)
PortalExecution PrepareForOutput(vtkm::Id numberOfValues, vtkm::cont::Token& token)
{
return PortalExecution{ this->Data.PrepareForOutput(numberOfValues, Device{}) };
return PortalExecution{ this->Data.PrepareForOutput(numberOfValues, Device{}, token) };
}
VTKM_CONT

7
vtkm/cont/ArrayHandleCartesianProduct.h
View File

@ -14,6 +14,7 @@
#include <vtkm/cont/ArrayHandle.h>
#include <vtkm/cont/ErrorBadAllocation.h>
#include <vtkm/cont/Token.h>
namespace vtkm
{
@ -336,7 +337,7 @@ public:
}
VTKM_CONT
PortalConstExecution PrepareForInput(bool vtkmNotUsed(updateData))
PortalConstExecution PrepareForInput(bool vtkmNotUsed(updateData), vtkm::cont::Token&)
{
return PortalConstExecution(this->FirstArray.PrepareForInput(Device()),
this->SecondArray.PrepareForInput(Device()),
@ -344,7 +345,7 @@ public:
}
VTKM_CONT
PortalExecution PrepareForInPlace(bool vtkmNotUsed(updateData))
PortalExecution PrepareForInPlace(bool vtkmNotUsed(updateData), vtkm::cont::Token&)
{
throw vtkm::cont::ErrorBadAllocation(
"Cannot write to an ArrayHandleCartesianProduct. It does not make "
@ -352,7 +353,7 @@ public:
}
VTKM_CONT
PortalExecution PrepareForOutput(vtkm::Id vtkmNotUsed(numberOfValues))
PortalExecution PrepareForOutput(vtkm::Id vtkmNotUsed(numberOfValues), vtkm::cont::Token&)
{
throw vtkm::cont::ErrorBadAllocation(
"Cannot write to an ArrayHandleCartesianProduct. It does not make "

59
vtkm/cont/ArrayHandleCompositeVector.h
View File

@ -132,27 +132,33 @@ struct ArrayTupleForEach
}
template <typename DeviceTag, typename PortalTuple>
VTKM_CONT static void PrepareForInput(const ArrayTuple& arrays, PortalTuple& portals)
VTKM_CONT static void PrepareForInput(const ArrayTuple& arrays,
PortalTuple& portals,
vtkm::cont::Token& token)
{
vtkmstd::get<Index>(portals) = vtkmstd::get<Index>(arrays).PrepareForInput(DeviceTag());
Next::template PrepareForInput<DeviceTag>(arrays, portals);
vtkmstd::get<Index>(portals) = vtkmstd::get<Index>(arrays).PrepareForInput(DeviceTag(), token);
Next::template PrepareForInput<DeviceTag>(arrays, portals, token);
}
template <typename DeviceTag, typename PortalTuple>
VTKM_CONT static void PrepareForInPlace(ArrayTuple& arrays, PortalTuple& portals)
VTKM_CONT static void PrepareForInPlace(ArrayTuple& arrays,
PortalTuple& portals,
vtkm::cont::Token& token)
{
vtkmstd::get<Index>(portals) = vtkmstd::get<Index>(arrays).PrepareForInPlace(DeviceTag());
Next::template PrepareForInPlace<DeviceTag>(arrays, portals);
vtkmstd::get<Index>(portals) =
vtkmstd::get<Index>(arrays).PrepareForInPlace(DeviceTag(), token);
Next::template PrepareForInPlace<DeviceTag>(arrays, portals, token);
}
template <typename DeviceTag, typename PortalTuple>
VTKM_CONT static void PrepareForOutput(ArrayTuple& arrays,
PortalTuple& portals,
vtkm::Id numValues)
vtkm::Id numValues,
vtkm::cont::Token& token)
{
vtkmstd::get<Index>(portals) =
vtkmstd::get<Index>(arrays).PrepareForOutput(numValues, DeviceTag());
Next::template PrepareForOutput<DeviceTag>(arrays, portals, numValues);
vtkmstd::get<Index>(arrays).PrepareForOutput(numValues, DeviceTag(), token);
Next::template PrepareForOutput<DeviceTag>(arrays, portals, numValues, token);
}
VTKM_CONT
@ -191,17 +197,17 @@ struct ArrayTupleForEach<Index, Index, ArrayTuple>
}
template <typename DeviceTag, typename PortalTuple>
VTKM_CONT static void PrepareForInput(const ArrayTuple&, PortalTuple&)
VTKM_CONT static void PrepareForInput(const ArrayTuple&, PortalTuple&, vtkm::cont::Token&)
{
}
template <typename DeviceTag, typename PortalTuple>
VTKM_CONT static void PrepareForInPlace(ArrayTuple&, PortalTuple&)
VTKM_CONT static void PrepareForInPlace(ArrayTuple&, PortalTuple&, vtkm::cont::Token&)
{
}
template <typename DeviceTag, typename PortalTuple>
VTKM_CONT static void PrepareForOutput(ArrayTuple&, PortalTuple&, vtkm::Id)
VTKM_CONT static void PrepareForOutput(ArrayTuple&, PortalTuple&, vtkm::Id, vtkm::cont::Token&)
{
}
@ -302,29 +308,30 @@ public:
template <typename DeviceTag>
VTKM_CONT static const typename ExecutionTypes<DeviceTag>::PortalConstTuple PrepareForInput(
const ArrayTuple& arrays)
const ArrayTuple& arrays,
vtkm::cont::Token& token)
{
typename ExecutionTypes<DeviceTag>::PortalConstTuple portals;
ForEachArray::template PrepareForInput<DeviceTag>(arrays, portals);
ForEachArray::template PrepareForInput<DeviceTag>(arrays, portals, token);
return portals;
}
template <typename DeviceTag>
VTKM_CONT static const typename ExecutionTypes<DeviceTag>::PortalTuple PrepareForInPlace(
ArrayTuple& arrays)
ArrayTuple& arrays,
vtkm::cont::Token& token)
{
typename ExecutionTypes<DeviceTag>::PortalTuple portals;
ForEachArray::template PrepareForInPlace<DeviceTag>(arrays, portals);
ForEachArray::template PrepareForInPlace<DeviceTag>(arrays, portals, token);
return portals;
}
template <typename DeviceTag>
VTKM_CONT static const typename ExecutionTypes<DeviceTag>::PortalTuple PrepareForOutput(
ArrayTuple& arrays,
vtkm::Id numValues)
VTKM_CONT static const typename ExecutionTypes<DeviceTag>::PortalTuple
PrepareForOutput(ArrayTuple& arrays, vtkm::Id numValues, vtkm::cont::Token& token)
{
typename ExecutionTypes<DeviceTag>::PortalTuple portals;
ForEachArray::template PrepareForOutput<DeviceTag>(arrays, portals, numValues);
ForEachArray::template PrepareForOutput<DeviceTag>(arrays, portals, numValues, token);
return portals;
}
};
@ -671,24 +678,24 @@ public:
vtkm::Id GetNumberOfValues() const { return this->Storage->GetNumberOfValues(); }
VTKM_CONT
PortalConstExecution PrepareForInput(bool vtkmNotUsed(updateData)) const
PortalConstExecution PrepareForInput(bool vtkmNotUsed(updateData), vtkm::cont::Token& token) const
{
return PortalConstExecution(
ControlTraits::template PrepareForInput<DeviceTag>(this->GetArrayTuple()));
ControlTraits::template PrepareForInput<DeviceTag>(this->GetArrayTuple(), token));
}
VTKM_CONT
PortalExecution PrepareForInPlace(bool vtkmNotUsed(updateData))
PortalExecution PrepareForInPlace(bool vtkmNotUsed(updateData), vtkm::cont::Token& token)
{
return PortalExecution(
ControlTraits::template PrepareForInPlace<DeviceTag>(this->GetArrayTuple()));
ControlTraits::template PrepareForInPlace<DeviceTag>(this->GetArrayTuple(), token));
}
VTKM_CONT
PortalExecution PrepareForOutput(vtkm::Id numValues)
PortalExecution PrepareForOutput(vtkm::Id numValues, vtkm::cont::Token& token)
{
return PortalExecution(
ControlTraits::template PrepareForOutput<DeviceTag>(this->GetArrayTuple(), numValues));
ControlTraits::template PrepareForOutput<DeviceTag>(this->GetArrayTuple(), numValues, token));
}
VTKM_CONT

14
vtkm/cont/ArrayHandleConcatenate.h
View File

@ -283,21 +283,21 @@ public:
}
VTKM_CONT
PortalConstExecution PrepareForInput(bool vtkmNotUsed(updateData))
PortalConstExecution PrepareForInput(bool vtkmNotUsed(updateData), vtkm::cont::Token& token)
{
return PortalConstExecution(this->array1.PrepareForInput(Device()),
this->array2.PrepareForInput(Device()));
return PortalConstExecution(this->array1.PrepareForInput(Device(), token),
this->array2.PrepareForInput(Device(), token));
}
VTKM_CONT
PortalExecution PrepareForInPlace(bool vtkmNotUsed(updateData))
PortalExecution PrepareForInPlace(bool vtkmNotUsed(updateData), vtkm::cont::Token& token)
{
return PortalExecution(this->array1.PrepareForInPlace(Device()),
this->array2.PrepareForInPlace(Device()));
return PortalExecution(this->array1.PrepareForInPlace(Device(), token),
this->array2.PrepareForInPlace(Device(), token));
}
VTKM_CONT
PortalExecution PrepareForOutput(vtkm::Id vtkmNotUsed(numberOfValues))
PortalExecution PrepareForOutput(vtkm::Id vtkmNotUsed(numberOfValues), vtkm::cont::Token&)
{
throw vtkm::cont::ErrorInternal("ArrayHandleConcatenate is derived and read-only. ");
}

88
vtkm/cont/ArrayHandleDecorator.h
View File

@ -226,34 +226,34 @@ typename std::decay<ArrayT>::type::PortalConstControl GetPortalControlImpl(std::
template <typename ArrayT, typename Device>
typename std::decay<ArrayT>::type::template ExecutionTypes<Device>::Portal
GetPortalInPlaceImpl(std::true_type, ArrayT&& array, Device)
GetPortalInPlaceImpl(std::true_type, ArrayT&& array, Device, vtkm::cont::Token& token)
{
return array.PrepareForInPlace(Device{});
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)
GetPortalInPlaceImpl(std::false_type, ArrayT&& array, Device, vtkm::cont::Token& token)
{
// ArrayT is read-only -- prepare for input instead.
return array.PrepareForInput(Device{});
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)
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{});
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)
GetPortalOutputImpl(std::false_type, ArrayT&& array, Device, vtkm::cont::Token& token)
{
// ArrayT is read-only -- prepare for input instead.
return array.PrepareForInput(Device{});
return array.PrepareForInput(Device{}, token);
}
} // namespace detail
@ -302,27 +302,26 @@ GetPortalConstControlType<typename std::decay<ArrayT>::type> GetPortalConstContr
}
template <typename ArrayT, typename Device>
GetPortalConstExecutionType<typename std::decay<ArrayT>::type, Device> GetPortalInput(
const ArrayT& array,
Device)
GetPortalConstExecutionType<typename std::decay<ArrayT>::type, Device>
GetPortalInput(const ArrayT& array, Device, vtkm::cont::Token& token)
{
return array.PrepareForInput(Device{});
return array.PrepareForInput(Device{}, token);
}
template <typename ArrayT, typename Device>
GetPortalExecutionType<typename std::decay<ArrayT>::type, Device> GetPortalInPlace(ArrayT&& array,
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{});
IsWritableArrayHandle<ArrayT>{}, std::forward<ArrayT>(array), Device{}, token);
}
template <typename ArrayT, typename Device>
GetPortalExecutionType<typename std::decay<ArrayT>::type, Device> GetPortalOutput(ArrayT&& array,
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{});
IsWritableArrayHandle<ArrayT>{}, std::forward<ArrayT>(array), Device{}, token);
}
// Equivalent to std::true_type if *any* portal in PortalList can be written to.
@ -381,16 +380,16 @@ using GetPortalConstControlList =
brigand::list<decltype((GetPortalConstControl(std::declval<ArrayTs&>())))...>;
template <typename Device, typename... ArrayTs>
using GetPortalConstExecutionList =
brigand::list<decltype((GetPortalInput(std::declval<ArrayTs&>(), Device{})))...>;
using GetPortalConstExecutionList = brigand::list<decltype(
(GetPortalInput(std::declval<ArrayTs&>(), Device{}, std::declval<vtkm::cont::Token&>())))...>;
template <typename... ArrayTs>
using GetPortalControlList =
brigand::list<decltype((GetPortalControl(std::declval<ArrayTs&>())))...>;
template <typename Device, typename... ArrayTs>
using GetPortalExecutionList =
brigand::list<decltype((GetPortalInPlace(std::declval<ArrayTs&>(), Device{})))...>;
using GetPortalExecutionList = brigand::list<decltype(
(GetPortalInPlace(std::declval<ArrayTs&>(), Device{}, std::declval<vtkm::cont::Token&>())))...>;
template <typename DecoratorImplT, typename... ArrayTs>
struct DecoratorStorageTraits
@ -576,14 +575,15 @@ struct DecoratorStorageTraits
const ArrayTupleType& arrays,
vtkm::Id numValues,
List<Indices...>,
Device dev)
Device dev,
vtkm::cont::Token& token)
{
return CreatePortalDecorator<PortalConstExecutionType<Device>>(
numValues,
impl,
// Don't touch the following line unless you really, really have to. See
// note in MakePortalControl.
GetPortalInput(vtkmstd::get<Indices{}.value>(arrays), dev)...);
GetPortalInput(vtkmstd::get<Indices{}.value>(arrays), dev, token)...);
}
template <template <typename...> class List, typename... Indices, typename Device>
@ -591,14 +591,15 @@ struct DecoratorStorageTraits
ArrayTupleType& arrays,
vtkm::Id numValues,
List<Indices...>,
Device dev)
Device dev,
vtkm::cont::Token& token)
{
return CreatePortalDecorator<PortalExecutionType<Device>>(
numValues,
impl,
// Don't touch the following line unless you really, really have to. See
// note in MakePortalControl.
GetPortalInPlace(vtkmstd::get<Indices{}.value>(arrays), dev)...);
GetPortalInPlace(vtkmstd::get<Indices{}.value>(arrays), dev, token)...);
}
template <template <typename...> class List, typename... Indices, typename Device>
@ -606,14 +607,15 @@ struct DecoratorStorageTraits
ArrayTupleType& arrays,
vtkm::Id numValues,
List<Indices...>,
Device dev)
Device dev,
vtkm::cont::Token& token)
{
return CreatePortalDecorator<PortalExecutionType<Device>>(
numValues,
impl,
// Don't touch the following line unless you really, really have to. See
// note in MakePortalControl.
GetPortalOutput(vtkmstd::get<Indices{}.value>(arrays), dev)...);
GetPortalOutput(vtkmstd::get<Indices{}.value>(arrays), dev, token)...);
}
template <template <typename...> class List, typename... Indices>
@ -662,10 +664,11 @@ struct DecoratorStorageTraits
const ArrayTupleType& arrays,
vtkm::Id numValues,
List<std::size_t, Indices...>,
Device dev)
Device dev,
vtkm::cont::Token& token)
{
return CreatePortalDecorator<PortalConstExecutionType<Device>>(
numValues, impl, GetPortalInput(vtkmstd::get<Indices>(arrays), dev)...);
numValues, impl, GetPortalInput(vtkmstd::get<Indices>(arrays), dev, token)...);
}
template <template <typename, std::size_t...> class List, std::size_t... Indices, typename Device>
@ -673,10 +676,11 @@ struct DecoratorStorageTraits
ArrayTupleType& arrays,
vtkm::Id numValues,
List<std::size_t, Indices...>,
Device dev)
Device dev,
vtkm::cont::Token& token)
{
return CreatePortalDecorator<PortalExecutionType<Device>>(
numValues, impl, GetPortalInPlace(vtkmstd::get<Indices>(arrays), dev)...);
numValues, impl, GetPortalInPlace(vtkmstd::get<Indices>(arrays), dev, token)...);
}
template <template <typename, std::size_t...> class List, std::size_t... Indices, typename Device>
@ -684,10 +688,11 @@ struct DecoratorStorageTraits
ArrayTupleType& arrays,
vtkm::Id numValues,
List<std::size_t, Indices...>,
Device dev)
Device dev,
vtkm::cont::Token& token)
{
return CreatePortalDecorator<PortalExecutionType<Device>>(
numValues, impl, GetPortalOutput(vtkmstd::get<Indices>(arrays), dev)...);
numValues, impl, GetPortalOutput(vtkmstd::get<Indices>(arrays), dev, token)...);
}
template <template <typename, std::size_t...> class List, std::size_t... Indices>
@ -871,33 +876,36 @@ public:
vtkm::Id GetNumberOfValues() const { return this->Storage->GetNumberOfValues(); }
VTKM_CONT
PortalConstExecution PrepareForInput(bool vtkmNotUsed(updateData)) const
PortalConstExecution PrepareForInput(bool vtkmNotUsed(updateData), vtkm::cont::Token& token) const
{
return Traits::MakePortalInput(this->Storage->GetImplementation(),
this->Storage->GetArrayTuple(),
this->Storage->GetNumberOfValues(),
IndexList{},
Device{});
Device{},
token);
}
VTKM_CONT
PortalExecution PrepareForInPlace(bool vtkmNotUsed(updateData))
PortalExecution PrepareForInPlace(bool vtkmNotUsed(updateData), vtkm::cont::Token& token)
{
return Traits::MakePortalInPlace(this->Storage->GetImplementation(),
this->Storage->GetArrayTuple(),
this->Storage->GetNumberOfValues(),
IndexList{},
Device{});
Device{},
token);
}
VTKM_CONT
PortalExecution PrepareForOutput(vtkm::Id)
PortalExecution PrepareForOutput(vtkm::Id, vtkm::cont::Token& token)
{
return Traits::MakePortalOutput(this->Storage->GetImplementation(),
this->Storage->GetArrayTuple(),
this->Storage->GetNumberOfValues(),
IndexList{},
Device{});
Device{},
token);
}
VTKM_CONT

6
vtkm/cont/ArrayHandleDiscard.h
View File

@ -148,21 +148,21 @@ public:
}
VTKM_CONT
PortalConstExecution PrepareForInput(bool vtkmNotUsed(updateData))
PortalConstExecution PrepareForInput(bool vtkmNotUsed(updateData), vtkm::cont::Token&)
{
throw vtkm::cont::ErrorBadValue("Input access not supported: "
"Cannot read from an ArrayHandleDiscard.");
}
VTKM_CONT
PortalExecution PrepareForInPlace(bool vtkmNotUsed(updateData))
PortalExecution PrepareForInPlace(bool vtkmNotUsed(updateData), vtkm::cont::Token&)
{
throw vtkm::cont::ErrorBadValue("InPlace access not supported: "
"Cannot read from an ArrayHandleDiscard.");
}
VTKM_CONT
PortalExecution PrepareForOutput(vtkm::Id numValues)
PortalExecution PrepareForOutput(vtkm::Id numValues, vtkm::cont::Token&)
{
VTKM_ASSERT(this->Internal != nullptr);
this->Internal->Allocate(numValues);

13
vtkm/cont/ArrayHandleExtractComponent.h
View File

@ -212,21 +212,22 @@ public:
vtkm::Id GetNumberOfValues() const { return this->Array.GetNumberOfValues(); }
VTKM_CONT
PortalConstExecution PrepareForInput(bool vtkmNotUsed(updateData))
PortalConstExecution PrepareForInput(bool vtkmNotUsed(updateData), vtkm::cont::Token& token)
{
return PortalConstExecution(this->Array.PrepareForInput(Device()), this->Component);
return PortalConstExecution(this->Array.PrepareForInput(Device(), token), this->Component);
}
VTKM_CONT
PortalExecution PrepareForInPlace(bool vtkmNotUsed(updateData))
PortalExecution PrepareForInPlace(bool vtkmNotUsed(updateData), vtkm::cont::Token& token)
{
return PortalExecution(this->Array.PrepareForInPlace(Device()), this->Component);
return PortalExecution(this->Array.PrepareForInPlace(Device(), token), this->Component);
}
VTKM_CONT
PortalExecution PrepareForOutput(vtkm::Id numberOfValues)
PortalExecution PrepareForOutput(vtkm::Id numberOfValues, vtkm::cont::Token& token)
{
return PortalExecution(this->Array.PrepareForOutput(numberOfValues, Device()), this->Component);
return PortalExecution(this->Array.PrepareForOutput(numberOfValues, Device(), token),
this->Component);
}
VTKM_CONT

12
vtkm/cont/ArrayHandleGroupVec.h
View File

@ -256,32 +256,32 @@ public:
}
VTKM_CONT
PortalConstExecution PrepareForInput(bool vtkmNotUsed(updateData))
PortalConstExecution PrepareForInput(bool vtkmNotUsed(updateData), vtkm::cont::Token& token)
{
if (this->SourceArray.GetNumberOfValues() % NUM_COMPONENTS != 0)
{
throw vtkm::cont::ErrorBadValue(
"ArrayHandleGroupVec's source array does not divide evenly into Vecs.");
}
return PortalConstExecution(this->SourceArray.PrepareForInput(Device()));
return PortalConstExecution(this->SourceArray.PrepareForInput(Device(), token));
}
VTKM_CONT
PortalExecution PrepareForInPlace(bool vtkmNotUsed(updateData))
PortalExecution PrepareForInPlace(bool vtkmNotUsed(updateData), vtkm::cont::Token& token)
{
if (this->SourceArray.GetNumberOfValues() % NUM_COMPONENTS != 0)
{
throw vtkm::cont::ErrorBadValue(
"ArrayHandleGroupVec's source array does not divide evenly into Vecs.");
}
return PortalExecution(this->SourceArray.PrepareForInPlace(Device()));
return PortalExecution(this->SourceArray.PrepareForInPlace(Device(), token));
}
VTKM_CONT
PortalExecution PrepareForOutput(vtkm::Id numberOfValues)
PortalExecution PrepareForOutput(vtkm::Id numberOfValues, vtkm::cont::Token& token)
{
return PortalExecution(
this->SourceArray.PrepareForOutput(numberOfValues * NUM_COMPONENTS, Device()));
this->SourceArray.PrepareForOutput(numberOfValues * NUM_COMPONENTS, Device(), token));
}
VTKM_CONT

18
vtkm/cont/ArrayHandleGroupVecVariable.h
View File

@ -312,27 +312,27 @@ public:
vtkm::Id GetNumberOfValues() const { return this->OffsetsArray.GetNumberOfValues(); }
VTKM_CONT
PortalConstExecution PrepareForInput(bool vtkmNotUsed(updateData))
PortalConstExecution PrepareForInput(bool vtkmNotUsed(updateData), vtkm::cont::Token& token)
{
return PortalConstExecution(this->SourceArray.PrepareForInput(Device()),
this->OffsetsArray.PrepareForInput(Device()));
return PortalConstExecution(this->SourceArray.PrepareForInput(Device(), token),
this->OffsetsArray.PrepareForInput(Device(), token));
}
VTKM_CONT
PortalExecution PrepareForInPlace(bool vtkmNotUsed(updateData))
PortalExecution PrepareForInPlace(bool vtkmNotUsed(updateData), vtkm::cont::Token& token)
{
return PortalExecution(this->SourceArray.PrepareForInPlace(Device()),
this->OffsetsArray.PrepareForInput(Device()));
return PortalExecution(this->SourceArray.PrepareForInPlace(Device(), token),
this->OffsetsArray.PrepareForInput(Device(), token));
}
VTKM_CONT
PortalExecution PrepareForOutput(vtkm::Id numberOfValues)
PortalExecution PrepareForOutput(vtkm::Id numberOfValues, vtkm::cont::Token& token)
{
// Cannot reallocate an ArrayHandleGroupVecVariable
VTKM_ASSERT(numberOfValues == this->OffsetsArray.GetNumberOfValues());
return PortalExecution(
this->SourceArray.PrepareForOutput(this->SourceArray.GetNumberOfValues(), Device()),
this->OffsetsArray.PrepareForInput(Device()));
this->SourceArray.PrepareForOutput(this->SourceArray.GetNumberOfValues(), Device(), token),
this->OffsetsArray.PrepareForInput(Device(), token));
}
VTKM_CONT

33
vtkm/cont/ArrayHandleMultiplexer.h
View File

@ -354,20 +354,24 @@ public:
VTKM_CONT vtkm::Id GetNumberOfValues() const { return this->StoragePointer->GetNumberOfValues(); }
VTKM_CONT PortalConstExecution PrepareForInput(bool vtkmNotUsed(updateData))
VTKM_CONT PortalConstExecution PrepareForInput(bool vtkmNotUsed(updateData),
vtkm::cont::Token& token)
{
return this->StoragePointer->GetArrayHandleVariant().CastAndCall(PrepareForInputFunctor{});
return this->StoragePointer->GetArrayHandleVariant().CastAndCall(PrepareForInputFunctor{},
token);
}
VTKM_CONT PortalExecution PrepareForInPlace(bool vtkmNotUsed(updateData))
VTKM_CONT PortalExecution PrepareForInPlace(bool vtkmNotUsed(updateData),
vtkm::cont::Token& token)
{
return this->StoragePointer->GetArrayHandleVariant().CastAndCall(PrepareForInPlaceFunctor{});
return this->StoragePointer->GetArrayHandleVariant().CastAndCall(PrepareForInPlaceFunctor{},
token);
}
VTKM_CONT PortalExecution PrepareForOutput(vtkm::Id numberOfValues)
VTKM_CONT PortalExecution PrepareForOutput(vtkm::Id numberOfValues, vtkm::cont::Token& token)
{
return this->StoragePointer->GetArrayHandleVariant().CastAndCall(PrepareForOutputFunctor{},
numberOfValues);
return this->StoragePointer->GetArrayHandleVariant().CastAndCall(
PrepareForOutputFunctor{}, numberOfValues, token);
}
VTKM_CONT void RetrieveOutputData(StorageType* vtkmNotUsed(storage)) const
@ -393,27 +397,30 @@ private:
struct PrepareForInputFunctor
{
template <typename ArrayHandleType>
VTKM_CONT PortalConstExecution operator()(const ArrayHandleType& array)
VTKM_CONT PortalConstExecution operator()(const ArrayHandleType& array,
vtkm::cont::Token& token)
{
return PortalConstExecution(array.PrepareForInput(Device{}));
return PortalConstExecution(array.PrepareForInput(Device{}, token));
}
};
struct PrepareForInPlaceFunctor
{
template <typename ArrayHandleType>
VTKM_CONT PortalExecution operator()(ArrayHandleType& array)
VTKM_CONT PortalExecution operator()(ArrayHandleType& array, vtkm::cont::Token& token)
{
return PortalExecution(array.PrepareForInPlace(Device{}));
return PortalExecution(array.PrepareForInPlace(Device{}, token));
}
};
struct PrepareForOutputFunctor
{
template <typename ArrayHandleType>
VTKM_CONT PortalExecution operator()(ArrayHandleType& array, vtkm::Id numberOfValues)
VTKM_CONT PortalExecution operator()(ArrayHandleType& array,
vtkm::Id numberOfValues,
vtkm::cont::Token& token)
{
return PortalExecution(array.PrepareForOutput(numberOfValues, Device{}));
return PortalExecution(array.PrepareForOutput(numberOfValues, Device{}, token));
}
};
};

18
vtkm/cont/ArrayHandlePermutation.h
View File

@ -234,21 +234,21 @@ public:
vtkm::Id GetNumberOfValues() const { return this->IndexArray.GetNumberOfValues(); }
VTKM_CONT
PortalConstExecution PrepareForInput(bool vtkmNotUsed(updateData))
PortalConstExecution PrepareForInput(bool vtkmNotUsed(updateData), vtkm::cont::Token& token)
{
return PortalConstExecution(this->IndexArray.PrepareForInput(Device()),
this->ValueArray.PrepareForInput(Device()));
return PortalConstExecution(this->IndexArray.PrepareForInput(Device(), token),
this->ValueArray.PrepareForInput(Device(), token));
}
VTKM_CONT
PortalExecution PrepareForInPlace(bool vtkmNotUsed(updateData))
PortalExecution PrepareForInPlace(bool vtkmNotUsed(updateData), vtkm::cont::Token& token)
{
return PortalExecution(this->IndexArray.PrepareForInput(Device()),
this->ValueArray.PrepareForInPlace(Device()));
return PortalExecution(this->IndexArray.PrepareForInput(Device(), token),
this->ValueArray.PrepareForInPlace(Device(), token));
}
VTKM_CONT
PortalExecution PrepareForOutput(vtkm::Id numberOfValues)
PortalExecution PrepareForOutput(vtkm::Id numberOfValues, vtkm::cont::Token& token)
{
if (numberOfValues != this->GetNumberOfValues())
{
@ -270,8 +270,8 @@ public:
}
return PortalExecution(
this->IndexArray.PrepareForInput(Device()),
this->ValueArray.PrepareForOutput(this->ValueArray.GetNumberOfValues(), Device()));
this->IndexArray.PrepareForInput(Device(), token),
this->ValueArray.PrepareForOutput(this->ValueArray.GetNumberOfValues(), Device(), token));
}
VTKM_CONT

12
vtkm/cont/ArrayHandleReverse.h
View File

@ -200,21 +200,21 @@ public:
vtkm::Id GetNumberOfValues() const { return this->Array.GetNumberOfValues(); }
VTKM_CONT
PortalConstExecution PrepareForInput(bool vtkmNotUsed(updateData))
PortalConstExecution PrepareForInput(bool vtkmNotUsed(updateData), vtkm::cont::Token& token)
{
return PortalConstExecution(this->Array.PrepareForInput(Device()));
return PortalConstExecution(this->Array.PrepareForInput(Device(), token));
}
VTKM_CONT
PortalExecution PrepareForInPlace(bool vtkmNotUsed(updateData))
PortalExecution PrepareForInPlace(bool vtkmNotUsed(updateData), vtkm::cont::Token& token)
{
return PortalExecution(this->Array.PrepareForInPlace(Device()));
return PortalExecution(this->Array.PrepareForInPlace(Device(), token));
}
VTKM_CONT
PortalExecution PrepareForOutput(vtkm::Id numberOfValues)
PortalExecution PrepareForOutput(vtkm::Id numberOfValues, vtkm::cont::Token& token)
{
return PortalExecution(this->Array.PrepareForOutput(numberOfValues, Device()));
return PortalExecution(this->Array.PrepareForOutput(numberOfValues, Device(), token));
}
VTKM_CONT

20
vtkm/cont/ArrayHandleSOA.h
View File

@ -349,27 +349,29 @@ public:
VTKM_CONT vtkm::Id GetNumberOfValues() const { return this->Storage->GetNumberOfValues(); }
VTKM_CONT PortalConstExecution PrepareForInput(bool vtkmNotUsed(updateData)) const
VTKM_CONT PortalConstExecution PrepareForInput(bool vtkmNotUsed(updateData),
vtkm::cont::Token& token) const
{
return detail::MakeSOAPortal<PortalConstExecution>(
this->Storage->GetArrays(), this->GetNumberOfValues(), [](const BaseArrayType& array) {
return array.PrepareForInput(Device{});
this->Storage->GetArrays(), this->GetNumberOfValues(), [&token](const BaseArrayType& array) {
return array.PrepareForInput(Device{}, token);
});
}
VTKM_CONT PortalExecution PrepareForInPlace(bool vtkmNotUsed(updateData)) const
VTKM_CONT PortalExecution PrepareForInPlace(bool vtkmNotUsed(updateData),
vtkm::cont::Token& token) const
{
return detail::MakeSOAPortal<PortalExecution>(
this->Storage->GetArrays(), this->GetNumberOfValues(), [](BaseArrayType& array) {
return array.PrepareForInPlace(Device{});
this->Storage->GetArrays(), this->GetNumberOfValues(), [&token](BaseArrayType& array) {
return array.PrepareForInPlace(Device{}, token);
});
}
VTKM_CONT PortalExecution PrepareForOutput(vtkm::Id numValues) const
VTKM_CONT PortalExecution PrepareForOutput(vtkm::Id numValues, vtkm::cont::Token& token) const
{
return detail::MakeSOAPortal<PortalExecution>(
this->Storage->GetArrays(), numValues, [numValues](BaseArrayType& array) {
return array.PrepareForOutput(numValues, Device{});
this->Storage->GetArrays(), numValues, [numValues, &token](BaseArrayType& array) {
return array.PrepareForOutput(numValues, Device{}, token);
});
}

13
vtkm/cont/ArrayHandleSwizzle.h
View File

@ -309,21 +309,22 @@ public:
vtkm::Id GetNumberOfValues() const { return this->Array.GetNumberOfValues(); }
VTKM_CONT
PortalConstExecution PrepareForInput(bool vtkmNotUsed(updateData))
PortalConstExecution PrepareForInput(bool vtkmNotUsed(updateData), vtkm::cont::Token& token)
{
return PortalConstExecution(this->Array.PrepareForInput(DeviceTag()), this->Map);
return PortalConstExecution(this->Array.PrepareForInput(DeviceTag(), token), this->Map);
}
VTKM_CONT
PortalExecution PrepareForInPlace(bool vtkmNotUsed(updateData))
PortalExecution PrepareForInPlace(bool vtkmNotUsed(updateData), vtkm::cont::Token& token)
{
return PortalExecution(this->Array.PrepareForInPlace(DeviceTag()), this->Map);
return PortalExecution(this->Array.PrepareForInPlace(DeviceTag(), token), this->Map);
}
VTKM_CONT
PortalExecution PrepareForOutput(vtkm::Id numberOfValues)
PortalExecution PrepareForOutput(vtkm::Id numberOfValues, vtkm::cont::Token& token)
{
return PortalExecution(this->Array.PrepareForOutput(numberOfValues, DeviceTag()), this->Map);
return PortalExecution(this->Array.PrepareForOutput(numberOfValues, DeviceTag(), token),
this->Map);
}
VTKM_CONT

50
vtkm/cont/ArrayHandleTransform.h
View File

@ -189,7 +189,7 @@ struct TransformFunctorManagerImpl<ProvidedFunctorType, std::false_type>
ProvidedFunctorType PrepareForControl() const { return this->Functor; }
template <typename Device>
VTKM_CONT ProvidedFunctorType PrepareForExecution(Device) const
VTKM_CONT ProvidedFunctorType PrepareForExecution(Device, vtkm::cont::Token&) const
{
return this->Functor;
}
@ -202,7 +202,8 @@ struct TransformFunctorManagerImpl<ProvidedFunctorType, std::true_type>
ProvidedFunctorType Functor;
// using FunctorType = decltype(std::declval<ProvidedFunctorType>().PrepareForControl());
using FunctorType = decltype(Functor.PrepareForControl());
// using FunctorType = decltype(Functor.PrepareForControl());
using FunctorType = vtkm::cont::internal::ControlObjectType<ProvidedFunctorType>;
TransformFunctorManagerImpl() = default;
@ -213,16 +214,17 @@ struct TransformFunctorManagerImpl<ProvidedFunctorType, std::true_type>
}
VTKM_CONT
auto PrepareForControl() const -> decltype(this->Functor.PrepareForControl())
auto PrepareForControl() const
-> decltype(vtkm::cont::internal::CallPrepareForControl(this->Functor))
{
return this->Functor.PrepareForControl();
return vtkm::cont::internal::CallPrepareForControl(this->Functor);
}
template <typename Device>
VTKM_CONT auto PrepareForExecution(Device device) const
-> decltype(this->Functor.PrepareForExecution(device))
VTKM_CONT auto PrepareForExecution(Device device, vtkm::cont::Token& token) const
-> decltype(vtkm::cont::internal::CallPrepareForExecution(this->Functor, device, token))
{
return this->Functor.PrepareForExecution(device);
return vtkm::cont::internal::CallPrepareForExecution(this->Functor, device, token);
}
};
@ -488,21 +490,21 @@ public:
vtkm::Id GetNumberOfValues() const { return this->Array.GetNumberOfValues(); }
VTKM_CONT
PortalConstExecution PrepareForInput(bool vtkmNotUsed(updateData))
PortalConstExecution PrepareForInput(bool vtkmNotUsed(updateData), vtkm::cont::Token& token)
{
return PortalConstExecution(this->Array.PrepareForInput(Device()),
this->Functor.PrepareForExecution(Device()));
return PortalConstExecution(this->Array.PrepareForInput(Device{}, token),
this->Functor.PrepareForExecution(Device{}, token));
}
VTKM_CONT
PortalExecution PrepareForInPlace(bool& vtkmNotUsed(updateData))
PortalExecution PrepareForInPlace(bool& vtkmNotUsed(updateData), vtkm::cont::Token&)
{
throw vtkm::cont::ErrorBadType("ArrayHandleTransform read only. "
"Cannot be used for in-place operations.");
}
VTKM_CONT
PortalExecution PrepareForOutput(vtkm::Id vtkmNotUsed(numberOfValues))
PortalExecution PrepareForOutput(vtkm::Id vtkmNotUsed(numberOfValues), vtkm::cont::Token&)
{
throw vtkm::cont::ErrorBadType("ArrayHandleTransform read only. Cannot be used as output.");
}
@ -573,27 +575,27 @@ public:
vtkm::Id GetNumberOfValues() const { return this->Array.GetNumberOfValues(); }
VTKM_CONT
PortalConstExecution PrepareForInput(bool vtkmNotUsed(updateData))
PortalConstExecution PrepareForInput(bool vtkmNotUsed(updateData), vtkm::cont::Token& token)
{
return PortalConstExecution(this->Array.PrepareForInput(Device()),
this->Functor.PrepareForExecution(Device()),
this->InverseFunctor.PrepareForExecution(Device()));
return PortalConstExecution(this->Array.PrepareForInput(Device{}, token),
this->Functor.PrepareForExecution(Device{}, token),
this->InverseFunctor.PrepareForExecution(Device{}, token));
}
VTKM_CONT
PortalExecution PrepareForInPlace(bool& vtkmNotUsed(updateData))
PortalExecution PrepareForInPlace(bool& vtkmNotUsed(updateData), vtkm::cont::Token& token)
{
return PortalExecution(this->Array.PrepareForInPlace(Device()),
this->Functor.PrepareForExecution(Device()),
this->InverseFunctor.PrepareForExecution(Device()));
return PortalExecution(this->Array.PrepareForInPlace(Device{}, token),
this->Functor.PrepareForExecution(Device{}, token),
this->InverseFunctor.PrepareForExecution(Device{}, token));
}
VTKM_CONT
PortalExecution PrepareForOutput(vtkm::Id numberOfValues)
PortalExecution PrepareForOutput(vtkm::Id numberOfValues, vtkm::cont::Token& token)
{
return PortalExecution(this->Array.PrepareForOutput(numberOfValues, Device()),
this->Functor.PrepareForExecution(Device()),
this->InverseFunctor.PrepareForExecution(Device()));
return PortalExecution(this->Array.PrepareForOutput(numberOfValues, Device{}, token),
this->Functor.PrepareForExecution(Device{}, token),
this->InverseFunctor.PrepareForExecution(Device{}, token));
}
VTKM_CONT

13
vtkm/cont/ArrayHandleView.h
View File

@ -242,21 +242,21 @@ public:
vtkm::Id GetNumberOfValues() const { return this->NumValues; }
VTKM_CONT
PortalConstExecution PrepareForInput(bool vtkmNotUsed(updateData))
PortalConstExecution PrepareForInput(bool vtkmNotUsed(updateData), vtkm::cont::Token& token)
{
return PortalConstExecution(
this->Array.PrepareForInput(Device()), this->StartIndex, this->NumValues);
this->Array.PrepareForInput(Device(), token), this->StartIndex, this->NumValues);
}
VTKM_CONT
PortalExecution PrepareForInPlace(bool vtkmNotUsed(updateData))
PortalExecution PrepareForInPlace(bool vtkmNotUsed(updateData), vtkm::cont::Token& token)
{
return PortalExecution(
this->Array.PrepareForInPlace(Device()), this->StartIndex, this->NumValues);
this->Array.PrepareForInPlace(Device(), token), this->StartIndex, this->NumValues);
}
VTKM_CONT
PortalExecution PrepareForOutput(vtkm::Id numberOfValues)
PortalExecution PrepareForOutput(vtkm::Id numberOfValues, vtkm::cont::Token& token)
{
if (numberOfValues != this->GetNumberOfValues())
{
@ -277,7 +277,8 @@ public:
"output of ArrayHandlePermutation.");
}
return PortalExecution(this->Array.PrepareForOutput(this->Array.GetNumberOfValues(), Device()),
return PortalExecution(
this->Array.PrepareForOutput(this->Array.GetNumberOfValues(), Device(), token),
this->StartIndex,
this->NumValues);
}

18
vtkm/cont/ArrayHandleZip.h
View File

@ -257,24 +257,24 @@ public:
}
VTKM_CONT
PortalConstExecution PrepareForInput(bool vtkmNotUsed(updateData))
PortalConstExecution PrepareForInput(bool vtkmNotUsed(updateData), vtkm::cont::Token& token)
{
return PortalConstExecution(this->FirstArray.PrepareForInput(Device()),
this->SecondArray.PrepareForInput(Device()));
return PortalConstExecution(this->FirstArray.PrepareForInput(Device(), token),
this->SecondArray.PrepareForInput(Device(), token));
}
VTKM_CONT
PortalExecution PrepareForInPlace(bool vtkmNotUsed(updateData))
PortalExecution PrepareForInPlace(bool vtkmNotUsed(updateData), vtkm::cont::Token& token)
{
return PortalExecution(this->FirstArray.PrepareForInPlace(Device()),
this->SecondArray.PrepareForInPlace(Device()));
return PortalExecution(this->FirstArray.PrepareForInPlace(Device(), token),
this->SecondArray.PrepareForInPlace(Device(), token));
}
VTKM_CONT
PortalExecution PrepareForOutput(vtkm::Id numberOfValues)
PortalExecution PrepareForOutput(vtkm::Id numberOfValues, vtkm::cont::Token& token)
{
return PortalExecution(this->FirstArray.PrepareForOutput(numberOfValues, Device()),
this->SecondArray.PrepareForOutput(numberOfValues, Device()));
return PortalExecution(this->FirstArray.PrepareForOutput(numberOfValues, Device(), token),
this->SecondArray.PrepareForOutput(numberOfValues, Device(), token));
}
VTKM_CONT

14
vtkm/cont/AtomicArray.h
View File

@ -72,9 +72,19 @@ public:
}
template <typename Device>
VTKM_CONT vtkm::exec::AtomicArrayExecutionObject<T, Device> PrepareForExecution(Device) const
VTKM_CONT vtkm::exec::AtomicArrayExecutionObject<T, Device> PrepareForExecution(
Device,
vtkm::cont::Token& token) const
{
return vtkm::exec::AtomicArrayExecutionObject<T, Device>(this->Handle);
return vtkm::exec::AtomicArrayExecutionObject<T, Device>(this->Handle, token);
}
template <typename Device>
VTKM_CONT VTKM_DEPRECATED(1.6, "PrepareForExecution now requires a vtkm::cont::Token object.")
vtkm::exec::AtomicArrayExecutionObject<T, Device> PrepareForExecution(Device device) const
{
vtkm::cont::Token token;
return this->PrepareForExecution(device, token);
}
private:

45
vtkm/cont/BitField.h
View File

@ -17,6 +17,7 @@
#include <vtkm/cont/ArrayHandle.h>
#include <vtkm/cont/Logging.h>
#include <vtkm/Deprecated.h>
#include <vtkm/List.h>
#include <vtkm/Types.h>
@ -647,13 +648,23 @@ public:
/// execution environment.
template <typename DeviceAdapterTag>
VTKM_CONT typename ExecutionTypes<DeviceAdapterTag>::PortalConst PrepareForInput(
DeviceAdapterTag device) const
DeviceAdapterTag device,
vtkm::cont::Token& token) const
{
using PortalType = typename ExecutionTypes<DeviceAdapterTag>::PortalConst;
return PortalType{ this->Internals->Data.PrepareForInput(device),
return PortalType{ this->Internals->Data.PrepareForInput(device, token),
this->Internals->NumberOfBits };
}
template <typename DeviceAdapterTag>
VTKM_CONT VTKM_DEPRECATED(1.6, "PrepareForInput now requires a vtkm::cont::Token object.")
typename ExecutionTypes<DeviceAdapterTag>::PortalConst
PrepareForInput(DeviceAdapterTag device) const
{
vtkm::cont::Token token;
return this->PrepareForInput(device, token);
}
/// Prepares (allocates) this BitField to be used as an output from an
/// operation in the execution environment. The internal state of this class
/// is set to have valid data in the execution BitField with the assumption
@ -661,9 +672,8 @@ public:
/// object are called). Returns a portal that can be used in code running in
/// the execution environment.
template <typename DeviceAdapterTag>
VTKM_CONT typename ExecutionTypes<DeviceAdapterTag>::Portal PrepareForOutput(
vtkm::Id numBits,
DeviceAdapterTag device) const
VTKM_CONT typename ExecutionTypes<DeviceAdapterTag>::Portal
PrepareForOutput(vtkm::Id numBits, DeviceAdapterTag device, vtkm::cont::Token& token) const
{
using PortalType = typename ExecutionTypes<DeviceAdapterTag>::Portal;
const vtkm::Id numWords = this->BitsToAllocatedStorageWords(numBits);
@ -675,11 +685,20 @@ public:
static_cast<vtkm::UInt64>(static_cast<size_t>(numWords) * sizeof(WordTypeDefault)))
.c_str());
auto portal = this->Internals->Data.PrepareForOutput(numWords, device);
auto portal = this->Internals->Data.PrepareForOutput(numWords, device, token);
this->Internals->NumberOfBits = numBits;
return PortalType{ portal, numBits };
}
template <typename DeviceAdapterTag>
VTKM_CONT VTKM_DEPRECATED(1.6, "PrepareForOutput now requires a vtkm::cont::Token object.")
typename ExecutionTypes<DeviceAdapterTag>::Portal
PrepareForOutput(vtkm::Id numBits, DeviceAdapterTag device) const
{
vtkm::cont::Token token;
return this->PrepareForOutput(numBits, device, token);
}
/// Prepares this BitField to be used in an in-place operation (both as input
/// and output) in the execution environment. If necessary, copies data to
/// the execution environment. Can throw an exception if this BitField does
@ -687,13 +706,23 @@ public:
/// running in the execution environment.
template <typename DeviceAdapterTag>
VTKM_CONT typename ExecutionTypes<DeviceAdapterTag>::Portal PrepareForInPlace(
DeviceAdapterTag device) const
DeviceAdapterTag device,
vtkm::cont::Token& token) const
{
using PortalType = typename ExecutionTypes<DeviceAdapterTag>::Portal;
return PortalType{ this->Internals->Data.PrepareForInPlace(device),
return PortalType{ this->Internals->Data.PrepareForInPlace(device, token),
this->Internals->NumberOfBits };
}
template <typename DeviceAdapterTag>
VTKM_CONT VTKM_DEPRECATED(1.6, "PrepareForInPlace now requires a vtkm::cont::Token object.")
typename ExecutionTypes<DeviceAdapterTag>::Portal
PrepareForInPlace(DeviceAdapterTag device) const
{
vtkm::cont::Token token;
return this->PrepareForInPlace(device, token);
}
private:
/// Returns the number of words, padded out to respect BlockSize.
VTKM_CONT

15
vtkm/cont/CellSetExplicit.h
View File

@ -239,7 +239,18 @@ public:
template <typename Device, typename VisitTopology, typename IncidentTopology>
VTKM_CONT typename ExecutionTypes<Device, VisitTopology, IncidentTopology>::ExecObjectType
PrepareForInput(Device, VisitTopology, IncidentTopology) const;
PrepareForInput(Device, VisitTopology, IncidentTopology, vtkm::cont::Token&) const;
template <typename Device, typename VisitTopology, typename IncidentTopology>
VTKM_DEPRECATED(1.6, "Provide a vtkm::cont::Token object when calling PrepareForInput.")
VTKM_CONT typename ExecutionTypes<Device, VisitTopology, IncidentTopology>::ExecObjectType
PrepareForInput(Device device,
VisitTopology visitTopology,
IncidentTopology incidentTopology) const
{
vtkm::cont::Token token;
return this->PrepareForInput(device, visitTopology, incidentTopology, token);
}
template <typename VisitTopology, typename IncidentTopology>
VTKM_CONT const typename ConnectivityChooser<VisitTopology, IncidentTopology>::ShapesArrayType&
@ -464,6 +475,8 @@ public:
} // diy
/// @endcond SERIALIZATION
#ifndef vtk_m_cont_CellSetExplicit_hxx
#include <vtkm/cont/CellSetExplicit.hxx>
#endif //vtk_m_cont_CellSetExplicit_hxx
#endif //vtk_m_cont_CellSetExplicit_h

8
vtkm/cont/CellSetExplicit.hxx
View File

@ -363,7 +363,7 @@ template <typename SST, typename CST, typename OST>
template <typename Device, typename VisitTopology, typename IncidentTopology>
VTKM_CONT
auto CellSetExplicit<SST, CST, OST>
::PrepareForInput(Device, VisitTopology, IncidentTopology) const
::PrepareForInput(Device, VisitTopology, IncidentTopology, vtkm::cont::Token& token) const
-> typename ExecutionTypes<Device,
VisitTopology,
IncidentTopology>::ExecObjectType
@ -378,9 +378,9 @@ auto CellSetExplicit<SST, CST, OST>
VisitTopology,
IncidentTopology>::ExecObjectType;
return ExecObjType(connectivity.Shapes.PrepareForInput(Device{}),
connectivity.Connectivity.PrepareForInput(Device{}),
connectivity.Offsets.PrepareForInput(Device{}));
return ExecObjType(connectivity.Shapes.PrepareForInput(Device{}, token),
connectivity.Connectivity.PrepareForInput(Device{}, token),
connectivity.Offsets.PrepareForInput(Device{}, token));
}
//----------------------------------------------------------------------------

26
vtkm/cont/CellSetExtrude.h
View File

@ -103,12 +103,34 @@ public:
template <typename Device>
ConnectivityP2C<Device> PrepareForInput(Device,
vtkm::TopologyElementTagCell,
vtkm::TopologyElementTagPoint) const;
vtkm::TopologyElementTagPoint,
vtkm::cont::Token&) const;
template <typename Device>
ConnectivityC2P<Device> PrepareForInput(Device,
vtkm::TopologyElementTagPoint,
vtkm::TopologyElementTagCell) const;
vtkm::TopologyElementTagCell,
vtkm::cont::Token&) const;
template <typename Device>
VTKM_DEPRECATED(1.6, "Provide a vtkm::cont::Token object when calling PrepareForInput.")
ConnectivityP2C<Device> PrepareForInput(Device device,
vtkm::TopologyElementTagCell visitTopology,
vtkm::TopologyElementTagPoint incidentTopology) const
{
vtkm::cont::Token token;
return this->PrepareForInput(device, visitTopology, incidentTopology, token);
}
template <typename Device>
VTKM_DEPRECATED(1.6, "Provide a vtkm::cont::Token object when calling PrepareForInput.")
ConnectivityC2P<Device> PrepareForInput(Device device,
vtkm::TopologyElementTagPoint visitTopology,
vtkm::TopologyElementTagCell incidentTopology) const
{
vtkm::cont::Token token;
this->PrepareForInput(device, visitTopology, incidentTopology, token);
}
private:
template <typename Device>

18
vtkm/cont/CellSetExtrude.hxx
View File

@ -87,10 +87,11 @@ template <typename Device>
CellSetExtrude::ConnectivityP2C<Device> CellSetExtrude::PrepareForInput(
Device,
vtkm::TopologyElementTagCell,
vtkm::TopologyElementTagPoint) const
vtkm::TopologyElementTagPoint,
vtkm::cont::Token& token) const
{
return ConnectivityP2C<Device>(this->Connectivity.PrepareForInput(Device{}),
this->NextNode.PrepareForInput(Device{}),
return ConnectivityP2C<Device>(this->Connectivity.PrepareForInput(Device{}, token),
this->NextNode.PrepareForInput(Device{}, token),
this->NumberOfCellsPerPlane,
this->NumberOfPointsPerPlane,
this->NumberOfPlanes,
@ -102,16 +103,17 @@ template <typename Device>
VTKM_CONT CellSetExtrude::ConnectivityC2P<Device> CellSetExtrude::PrepareForInput(
Device,
vtkm::TopologyElementTagPoint,
vtkm::TopologyElementTagCell) const
vtkm::TopologyElementTagCell,
vtkm::cont::Token& token) const
{
if (!this->ReverseConnectivityBuilt)
{
const_cast<CellSetExtrude*>(this)->BuildReverseConnectivity(Device{});
}
return ConnectivityC2P<Device>(this->RConnectivity.PrepareForInput(Device{}),
this->ROffsets.PrepareForInput(Device{}),
this->RCounts.PrepareForInput(Device{}),
this->PrevNode.PrepareForInput(Device{}),
return ConnectivityC2P<Device>(this->RConnectivity.PrepareForInput(Device{}, token),
this->ROffsets.PrepareForInput(Device{}, token),
this->RCounts.PrepareForInput(Device{}, token),
this->PrevNode.PrepareForInput(Device{}, token),
this->NumberOfCellsPerPlane,
this->NumberOfPointsPerPlane,
this->NumberOfPlanes);

28
vtkm/cont/CellSetPermutation.h
View File

@ -442,21 +442,26 @@ public:
vtkm::TopologyElementTagCell,
vtkm::TopologyElementTagPoint>::ExecObjectType
PrepareForInput(Device device,
vtkm::TopologyElementTagCell from,
vtkm::TopologyElementTagPoint to) const
vtkm::TopologyElementTagCell visitTopology,
vtkm::TopologyElementTagPoint incidentTopology,
vtkm::cont::Token& token) const
{
using ConnectivityType = typename ExecutionTypes<Device,
vtkm::TopologyElementTagCell,
vtkm::TopologyElementTagPoint>::ExecObjectType;
return ConnectivityType(this->ValidCellIds.PrepareForInput(device),
this->FullCellSet.PrepareForInput(device, from, to));
return ConnectivityType(
this->ValidCellIds.PrepareForInput(device, token),
this->FullCellSet.PrepareForInput(device, visitTopology, incidentTopology, token));
}
template <typename Device>
VTKM_CONT typename ExecutionTypes<Device,
vtkm::TopologyElementTagPoint,
vtkm::TopologyElementTagCell>::ExecObjectType
PrepareForInput(Device device, vtkm::TopologyElementTagPoint, vtkm::TopologyElementTagCell) const
PrepareForInput(Device device,
vtkm::TopologyElementTagPoint,
vtkm::TopologyElementTagCell,
vtkm::cont::Token& token) const
{
if (!this->VisitPointsWithCells.ElementsValid)
{
@ -468,8 +473,17 @@ public:
using ConnectivityType = typename ExecutionTypes<Device,
vtkm::TopologyElementTagPoint,
vtkm::TopologyElementTagCell>::ExecObjectType;
return ConnectivityType(this->VisitPointsWithCells.Connectivity.PrepareForInput(device),
this->VisitPointsWithCells.Offsets.PrepareForInput(device));
return ConnectivityType(this->VisitPointsWithCells.Connectivity.PrepareForInput(device, token),
this->VisitPointsWithCells.Offsets.PrepareForInput(device, token));
}
template <typename Device, typename VisitTopology, typename IncidentTopology>
VTKM_CONT VTKM_DEPRECATED(1.6, "Provide a vtkm::cont::Token object when calling PrepareForInput.")
typename ExecutionTypes<Device, VisitTopology, IncidentTopology>::ExecObjectType
PrepareForInput(Device device, VisitTopology visitTopology, IncidentTopology incidentTopology)
{
vtkm::cont::Token token;
return this->PrepareForInput(device, visitTopology, incidentTopology, token);
}
VTKM_CONT

13
vtkm/cont/CellSetStructured.h
View File

@ -115,7 +115,18 @@ public:
template <typename DeviceAdapter, typename VisitTopology, typename IncidentTopology>
typename ExecutionTypes<DeviceAdapter, VisitTopology, IncidentTopology>::ExecObjectType
PrepareForInput(DeviceAdapter, VisitTopology, IncidentTopology) const;
PrepareForInput(DeviceAdapter, VisitTopology, IncidentTopology, vtkm::cont::Token&) const;
template <typename DeviceAdapter, typename VisitTopology, typename IncidentTopology>
VTKM_DEPRECATED(1.6, "Provide a vtkm::cont::Token object when calling PrepareForInput.")
typename ExecutionTypes<DeviceAdapter, VisitTopology, IncidentTopology>::ExecObjectType
PrepareForInput(DeviceAdapter device,
VisitTopology visitTopology,
IncidentTopology incidentTopology) const
{
vtkm::cont::Token token;
return this->PrepareForInput(device, visitTopology, incidentTopology, token);
}
void PrintSummary(std::ostream& out) const override;

3
vtkm/cont/CellSetStructured.hxx
View File

@ -31,7 +31,8 @@ typename CellSetStructured<DIMENSION>::template ExecutionTypes<DeviceAdapter,
IncidentTopology>::ExecObjectType
CellSetStructured<DIMENSION>::PrepareForInput(DeviceAdapter,
VisitTopology,
IncidentTopology) const
IncidentTopology,
vtkm::cont::Token&) const
{
using ConnectivityType =
typename ExecutionTypes<DeviceAdapter, VisitTopology, IncidentTopology>::ExecObjectType;

38
vtkm/cont/ExecutionAndControlObjectBase.h
View File

@ -55,18 +55,46 @@ struct HasPrepareForControl
{
};
} // namespace internal
}
} // namespace vtkm::cont
/// Checks that the argument is a proper execution object.
///
#define VTKM_IS_EXECUTION_AND_CONTROL_OBJECT(execObject) \
static_assert(::vtkm::cont::internal::IsExecutionAndControlObjectBase<execObject>::value, \
"Provided type is not a subclass of vtkm::cont::ExecutionAndControlObjectBase."); \
static_assert(::vtkm::cont::internal::HasPrepareForExecution<execObject>::value, \
static_assert(::vtkm::cont::internal::HasPrepareForExecution<execObject>::value || \
::vtkm::cont::internal::HasPrepareForExecutionDeprecated<execObject>::value, \
"Provided type does not have requisite PrepareForExecution method."); \
static_assert(::vtkm::cont::internal::HasPrepareForControl<execObject>::value, \
"Provided type does not have requisite PrepareForControl method.")
/// \brief Gets the object to use in the control environment from an ExecutionAndControlObject.
///
/// An execution and control object (that is, an object inheriting from
/// `vtkm::cont::ExecutionAndControlObjectBase`) is really a control object factory that generates
/// a objects to be used in either the execution environment or the control environment. This
/// function takes a subclass of `ExecutionAndControlObjectBase` and returns the control object.
///
template <typename T>
VTKM_CONT auto CallPrepareForControl(T&& execObject) -> decltype(execObject.PrepareForControl())
{
VTKM_IS_EXECUTION_AND_CONTROL_OBJECT(T);
return execObject.PrepareForControl();
}
/// \brief Gets the object to use in the control environment from an ExecutionAndControlObject.
///
/// An execution and control object (that is, an object inheriting from
/// `vtkm::cont::ExecutionAndControlObjectBase`) is really a control object factory that generates
/// a objects to be used in either the execution environment or the control environment. This
/// templated type gives the type for the class used in the control environment for a given
/// ExecutionAndControlObject.
///
template <typename ExecutionAndControlObject>
using ControlObjectType =
decltype(CallPrepareForControl(std::declval<ExecutionAndControlObject>()));
} // namespace internal
}
} // namespace vtkm::cont
#endif //vtk_m_cont_ExecutionAndControlObjectBase_h

107
vtkm/cont/ExecutionObjectBase.h
View File

@ -10,8 +10,11 @@
#ifndef vtk_m_cont_ExecutionObjectBase_h
#define vtk_m_cont_ExecutionObjectBase_h
#include <vtkm/Deprecated.h>
#include <vtkm/Types.h>
#include <vtkm/cont/Token.h>
#include <vtkm/cont/serial/internal/DeviceAdapterTagSerial.h>
namespace vtkm
@ -19,11 +22,12 @@ namespace vtkm
namespace cont
{
/// Base \c ExecutionObjectBase for execution objects to inherit from so that
/// Base `ExecutionObjectBase` for execution objects to inherit from so that
/// you can use an arbitrary object as a parameter in an execution environment
/// function. Any subclass of \c ExecutionObjectBase must implement a
/// \c PrepareForExecution method that takes a device adapter tag and returns
/// an object for that device.
/// function. Any subclass of `ExecutionObjectBase` must implement a
/// `PrepareForExecution` method that takes a device adapter tag and a
/// `vtkm::cont::Token` and then returns an object for that device. The object
/// must be valid as long as the `Token` is in scope.
///
struct ExecutionObjectBase
{
@ -36,6 +40,17 @@ namespace detail
{
struct CheckPrepareForExecution
{
template <typename T>
static auto check(T* p) -> decltype(p->PrepareForExecution(vtkm::cont::DeviceAdapterTagSerial{},
std::declval<vtkm::cont::Token&>()),
std::true_type());
template <typename T>
static auto check(...) -> std::false_type;
};
struct CheckPrepareForExecutionDeprecated
{
template <typename T>
static auto check(T* p)
@ -57,16 +72,92 @@ struct HasPrepareForExecution
{
};
} // namespace internal
}
} // namespace vtkm::cont
template <typename T>
struct HasPrepareForExecutionDeprecated
: decltype(
detail::CheckPrepareForExecutionDeprecated::check<typename std::decay<T>::type>(nullptr))
{
};
/// Checks that the argument is a proper execution object.
///
#define VTKM_IS_EXECUTION_OBJECT(execObject) \
static_assert(::vtkm::cont::internal::IsExecutionObjectBase<execObject>::value, \
"Provided type is not a subclass of vtkm::cont::ExecutionObjectBase."); \
static_assert(::vtkm::cont::internal::HasPrepareForExecution<execObject>::value, \
static_assert(::vtkm::cont::internal::HasPrepareForExecution<execObject>::value || \
::vtkm::cont::internal::HasPrepareForExecutionDeprecated<execObject>::value, \
"Provided type does not have requisite PrepareForExecution method.")
namespace detail
{
template <typename T, typename Device>
VTKM_CONT auto CallPrepareForExecutionImpl(T&& execObject,
Device device,
vtkm::cont::Token& token,
std::true_type,
std::false_type)
-> decltype(execObject.PrepareForExecution(device, token))
{
return execObject.PrepareForExecution(device, token);
}
template <typename T, typename Device>
VTKM_DEPRECATED(
1.6,
"ExecutionObjects now require a PrepareForExecution that takes a vtkm::cont::Token object."
"PrepareForExecution(Device) is deprecated. Implement PrepareForExecution(Device, Token).")
VTKM_CONT auto CallPrepareForExecutionImpl(T&& execObject,
Device device,
vtkm::cont::Token&,
std::false_type,
std::true_type)
-> decltype(execObject.PrepareForExecution(device))
{
return execObject.PrepareForExecution(device);
}
} // namespace detail
/// \brief Gets the object to use in the execution environment from an ExecutionObject.
///
/// An execution object (that is, an object inheriting from `vtkm::cont::ExecutionObjectBase`) is
/// really a control object factory that generates an object to be used in the execution
/// environment for a particular device. This function takes a subclass of `ExecutionObjectBase`
/// and returns the execution object for a given device.
///
template <typename T, typename Device>
VTKM_CONT auto CallPrepareForExecution(T&& execObject, Device device, vtkm::cont::Token& token)
-> decltype(detail::CallPrepareForExecutionImpl(std::forward<T>(execObject),
device,
token,
HasPrepareForExecution<T>{},
HasPrepareForExecutionDeprecated<T>{}))
{
VTKM_IS_EXECUTION_OBJECT(T);
VTKM_IS_DEVICE_ADAPTER_TAG(Device);
return detail::CallPrepareForExecutionImpl(std::forward<T>(execObject),
device,
token,
HasPrepareForExecution<T>{},
HasPrepareForExecutionDeprecated<T>{});
}
/// \brief Gets the type of the execution-side object for an ExecutionObject.
///
/// An execution object (that is, an object inheriting from `vtkm::cont::ExecutionObjectBase`) is
/// really a control object factory that generates an object to be used in the execution
/// environment for a particular device. This templated type gives the type for the class used
/// in the execution environment for a given ExecutionObject and device.
///
template <typename ExecutionObject, typename Device>
using ExecutionObjectType = decltype(CallPrepareForExecution(std::declval<ExecutionObject>(),
Device{},
std::declval<vtkm::cont::Token&>()));
} // namespace internal
}
} // namespace vtkm::cont
#endif //vtk_m_cont_ExecutionObjectBase_h

16
vtkm/cont/StorageExtrude.h
View File

@ -33,7 +33,9 @@ struct VTKM_ALWAYS_EXPORT ArrayPortalExtrudePlane
VTKM_EXEC_CONT
ArrayPortalExtrudePlane()
: Portal()
, NumberOfPlanes(0){};
, NumberOfPlanes(0)
{
}
ArrayPortalExtrudePlane(const PortalType& p, vtkm::Int32 numOfPlanes)
: Portal(p)
@ -248,7 +250,9 @@ struct VTKM_ALWAYS_EXPORT ArrayPortalExtrude
: Portal()
, NumberOfValues(0)
, NumberOfPlanes(0)
, UseCylindrical(false){};
, UseCylindrical(false)
{
}
VTKM_SUPPRESS_EXEC_WARNINGS
VTKM_EXEC_CONT
@ -484,24 +488,24 @@ public:
vtkm::Id GetNumberOfValues() const { return this->ControlData->GetNumberOfValues(); }
VTKM_CONT
PortalConstExecution PrepareForInput(bool vtkmNotUsed(updateData))
PortalConstExecution PrepareForInput(bool vtkmNotUsed(updateData), vtkm::cont::Token& token)
{
return PortalConstExecution(
this->ControlData->Array.PrepareForInput(Device()),
this->ControlData->Array.PrepareForInput(Device(), token),
static_cast<vtkm::Int32>(this->ControlData->Array.GetNumberOfValues()),
this->ControlData->GetNumberOfPlanes(),
this->ControlData->GetUseCylindrical());
}
VTKM_CONT
PortalExecution PrepareForInPlace(bool& vtkmNotUsed(updateData))
PortalExecution PrepareForInPlace(bool& vtkmNotUsed(updateData), vtkm::cont::Token&)
{
throw vtkm::cont::ErrorBadType("StorageExtrude read only. "
"Cannot be used for in-place operations.");
}
VTKM_CONT
PortalExecution PrepareForOutput(vtkm::Id vtkmNotUsed(numberOfValues))
PortalExecution PrepareForOutput(vtkm::Id vtkmNotUsed(numberOfValues), vtkm::cont::Token&)
{
throw vtkm::cont::ErrorBadType("StorageExtrude read only. Cannot be used as output.");
}

7
vtkm/cont/StorageImplicit.h
View File

@ -15,6 +15,7 @@
#include <vtkm/cont/ArrayPortalToIterators.h>
#include <vtkm/cont/ErrorBadValue.h>
#include <vtkm/cont/Storage.h>
#include <vtkm/cont/Token.h>
#include <vtkm/cont/internal/ArrayTransfer.h>
@ -120,7 +121,7 @@ public:
vtkm::Id GetNumberOfValues() const { return this->Storage->GetNumberOfValues(); }
VTKM_CONT
PortalConstExecution PrepareForInput(bool vtkmNotUsed(updateData))
PortalConstExecution PrepareForInput(bool vtkmNotUsed(updateData), vtkm::cont::Token&)
{
return this->Storage->GetPortalConst();
}
@ -136,14 +137,14 @@ public:
VTKM_CONT
NO_OPTIMIZE_FUNC_ATTRIBUTE
PortalExecution PrepareForInPlace(bool vtkmNotUsed(updateData))
PortalExecution PrepareForInPlace(bool vtkmNotUsed(updateData), vtkm::cont::Token&)
{
throw vtkm::cont::ErrorBadValue("Implicit arrays cannot be used for output or in place.");
}
VTKM_CONT
NO_OPTIMIZE_FUNC_ATTRIBUTE
PortalExecution PrepareForOutput(vtkm::Id vtkmNotUsed(numberOfValues))
PortalExecution PrepareForOutput(vtkm::Id vtkmNotUsed(numberOfValues), vtkm::cont::Token&)
{
throw vtkm::cont::ErrorBadValue("Implicit arrays cannot be used for output.");
}

9
vtkm/cont/StorageVirtual.hxx
View File

@ -412,17 +412,20 @@ struct ArrayTransfer<T, vtkm::cont::StorageTagVirtual, Device> : detail::ArrayTr
{
}
VTKM_CONT typename Superclass::PortalConstExecution PrepareForInput(bool vtkmNotUsed(updateData))
VTKM_CONT typename Superclass::PortalConstExecution PrepareForInput(bool vtkmNotUsed(updateData),
vtkm::cont::Token&)
{
return this->Superclass::PrepareForInput(Device());
}
VTKM_CONT typename Superclass::PortalExecution PrepareForOutput(vtkm::Id numberOfValues)
VTKM_CONT typename Superclass::PortalExecution PrepareForOutput(vtkm::Id numberOfValues,
vtkm::cont::Token&)
{
return this->Superclass::PrepareForOutput(numberOfValues, Device());
}
VTKM_CONT typename Superclass::PortalExecution PrepareForInPlace(bool vtkmNotUsed(updateData))
VTKM_CONT typename Superclass::PortalExecution PrepareForInPlace(bool vtkmNotUsed(updateData),
vtkm::cont::Token&)
{
return this->Superclass::PrepareForInPlace(Device());
}

5
vtkm/cont/arg/TransportTagArrayIn.h
View File

@ -43,14 +43,15 @@ struct Transport<vtkm::cont::arg::TransportTagArrayIn, ContObjectType, Device>
VTKM_CONT ExecObjectType operator()(const ContObjectType& object,
const InputDomainType& vtkmNotUsed(inputDomain),
vtkm::Id inputRange,
vtkm::Id vtkmNotUsed(outputRange)) const
vtkm::Id vtkmNotUsed(outputRange),
vtkm::cont::Token& token) const
{
if (object.GetNumberOfValues() != inputRange)
{
throw vtkm::cont::ErrorBadValue("Input array to worklet invocation the wrong size.");
}
return object.PrepareForInput(Device());
return object.PrepareForInput(Device(), token);
}
};
}

5
vtkm/cont/arg/TransportTagArrayInOut.h
View File

@ -46,14 +46,15 @@ struct Transport<vtkm::cont::arg::TransportTagArrayInOut, ContObjectType, Device
VTKM_CONT ExecObjectType operator()(ContObjectType& object,
const InputDomainType& vtkmNotUsed(inputDomain),
vtkm::Id vtkmNotUsed(inputRange),
vtkm::Id outputRange) const
vtkm::Id outputRange,
vtkm::cont::Token& token) const
{
if (object.GetNumberOfValues() != outputRange)
{
throw vtkm::cont::ErrorBadValue("Input/output array to worklet invocation the wrong size.");
}
return object.PrepareForInPlace(Device());
return object.PrepareForInPlace(Device(), token);
}
};
}

5
vtkm/cont/arg/TransportTagArrayOut.h
View File

@ -46,9 +46,10 @@ struct Transport<vtkm::cont::arg::TransportTagArrayOut, ContObjectType, Device>
VTKM_CONT ExecObjectType operator()(ContObjectType& object,
const InputDomainType& vtkmNotUsed(inputDomain),
vtkm::Id vtkmNotUsed(inputRange),
vtkm::Id outputRange) const
vtkm::Id outputRange,
vtkm::cont::Token& token) const
{
return object.PrepareForOutput(outputRange, Device());
return object.PrepareForOutput(outputRange, Device(), token);
}
};
}

5
vtkm/cont/arg/TransportTagAtomicArray.h
View File

@ -54,13 +54,14 @@ struct Transport<vtkm::cont::arg::TransportTagAtomicArray,
operator()(vtkm::cont::ArrayHandle<T, vtkm::cont::StorageTagBasic>& array,
const InputDomainType&,
vtkm::Id,
vtkm::Id) const
vtkm::Id,
vtkm::cont::Token& token) const
{
// Note: we ignore the size of the domain because the randomly accessed
// array might not have the same size depending on how the user is using
// the array.
ExecType obj(array);
return obj.PrepareForExecution(Device());
return obj.PrepareForExecution(Device(), token);
}
};

27
vtkm/cont/arg/TransportTagBitField.h
View File

@ -38,10 +38,13 @@ struct Transport<vtkm::cont::arg::TransportTagBitFieldIn, vtkm::cont::BitField,
typename vtkm::cont::BitField::template ExecutionTypes<Device>::PortalConst;
template <typename InputDomainType>
VTKM_CONT ExecObjectType
operator()(vtkm::cont::BitField& field, const InputDomainType&, vtkm::Id, vtkm::Id) const
VTKM_CONT ExecObjectType operator()(vtkm::cont::BitField& field,
const InputDomainType&,
vtkm::Id,
vtkm::Id,
vtkm::cont::Token& token) const
{
return field.PrepareForInput(Device{});
return field.PrepareForInput(Device{}, token);
}
};
@ -51,12 +54,15 @@ struct Transport<vtkm::cont::arg::TransportTagBitFieldOut, vtkm::cont::BitField,
using ExecObjectType = typename vtkm::cont::BitField::template ExecutionTypes<Device>::Portal;
template <typename InputDomainType>
VTKM_CONT ExecObjectType
operator()(vtkm::cont::BitField& field, const InputDomainType&, vtkm::Id, vtkm::Id) const
VTKM_CONT ExecObjectType operator()(vtkm::cont::BitField& field,
const InputDomainType&,
vtkm::Id,
vtkm::Id,
vtkm::cont::Token& token) const
{
// This behaves similarly to WholeArray tags, where "Out" maps to InPlace
// since we don't want to reallocate or enforce size restrictions.
return field.PrepareForInPlace(Device{});
return field.PrepareForInPlace(Device{}, token);
}
};
@ -66,10 +72,13 @@ struct Transport<vtkm::cont::arg::TransportTagBitFieldInOut, vtkm::cont::BitFiel
using ExecObjectType = typename vtkm::cont::BitField::template ExecutionTypes<Device>::Portal;
template <typename InputDomainType>
VTKM_CONT ExecObjectType
operator()(vtkm::cont::BitField& field, const InputDomainType&, vtkm::Id, vtkm::Id) const
VTKM_CONT ExecObjectType operator()(vtkm::cont::BitField& field,
const InputDomainType&,
vtkm::Id,
vtkm::Id,
vtkm::cont::Token& token) const
{
return field.PrepareForInPlace(Device{});
return field.PrepareForInPlace(Device{}, token);
}
};
}

9
vtkm/cont/arg/TransportTagCellSetIn.h
View File

@ -47,10 +47,13 @@ struct Transport<vtkm::cont::arg::TransportTagCellSetIn<VisitTopology, IncidentT
std::declval<ContObjectType>().PrepareForInput(Device(), VisitTopology(), IncidentTopology()));
template <typename InputDomainType>
VTKM_CONT ExecObjectType
operator()(const ContObjectType& object, const InputDomainType&, vtkm::Id, vtkm::Id) const
VTKM_CONT ExecObjectType operator()(const ContObjectType& object,
const InputDomainType&,
vtkm::Id,
vtkm::Id,
vtkm::cont::Token& token) const
{
return object.PrepareForInput(Device(), VisitTopology(), IncidentTopology());
return object.PrepareForInput(Device(), VisitTopology(), IncidentTopology(), token);
}
};
}

11
vtkm/cont/arg/TransportTagExecObject.h
View File

@ -41,12 +41,15 @@ struct Transport<vtkm::cont::arg::TransportTagExecObject, ContObjectType, Device
// inherit from vtkm::cont::ExecutionObjectBase and have a PrepareForExecution method.
VTKM_IS_EXECUTION_OBJECT(ContObjectType);
using ExecObjectType = decltype(std::declval<ContObjectType>().PrepareForExecution(Device()));
using ExecObjectType = vtkm::cont::internal::ExecutionObjectType<ContObjectType, Device>;
template <typename InputDomainType>
VTKM_CONT ExecObjectType
operator()(ContObjectType& object, const InputDomainType&, vtkm::Id, vtkm::Id) const
VTKM_CONT ExecObjectType operator()(ContObjectType& object,
const InputDomainType&,
vtkm::Id,
vtkm::Id,
vtkm::cont::Token& token) const
{
return object.PrepareForExecution(Device());
return vtkm::cont::internal::CallPrepareForExecution(object, Device{}, token);
}
};
}

5
vtkm/cont/arg/TransportTagTopologyFieldIn.h
View File

@ -84,14 +84,15 @@ struct Transport<vtkm::cont::arg::TransportTagTopologyFieldIn<TopologyElementTag
ExecObjectType operator()(const ContObjectType& object,
const vtkm::cont::CellSet& inputDomain,
vtkm::Id,
vtkm::Id) const
vtkm::Id,
vtkm::cont::Token& token) const
{
if (object.GetNumberOfValues() != detail::TopologyDomainSize(inputDomain, TopologyElementTag()))
{
throw vtkm::cont::ErrorBadValue("Input array to worklet invocation the wrong size.");
}
return object.PrepareForInput(Device());
return object.PrepareForInput(Device(), token);
}
};
}

9
vtkm/cont/arg/TransportTagWholeArrayIn.h
View File

@ -50,14 +50,17 @@ struct Transport<vtkm::cont::arg::TransportTagWholeArrayIn, ContObjectType, Devi
using ExecObjectType = vtkm::exec::ExecutionWholeArrayConst<ValueType, StorageTag, Device>;
template <typename InputDomainType>
VTKM_CONT ExecObjectType
operator()(ContObjectType& array, const InputDomainType&, vtkm::Id, vtkm::Id) const
VTKM_CONT ExecObjectType operator()(ContObjectType& array,
const InputDomainType&,
vtkm::Id,
vtkm::Id,
vtkm::cont::Token& token) const
{
// Note: we ignore the size of the domain because the randomly accessed
// array might not have the same size depending on how the user is using
// the array.
return ExecObjectType(array);
return ExecObjectType(array, token);
}
};
}

9
vtkm/cont/arg/TransportTagWholeArrayInOut.h
View File

@ -52,14 +52,17 @@ struct Transport<vtkm::cont::arg::TransportTagWholeArrayInOut, ContObjectType, D
using ExecObjectType = vtkm::exec::ExecutionWholeArray<ValueType, StorageTag, Device>;
template <typename InputDomainType>
VTKM_CONT ExecObjectType
operator()(ContObjectType& array, const InputDomainType&, vtkm::Id, vtkm::Id) const
VTKM_CONT ExecObjectType operator()(ContObjectType& array,
const InputDomainType&,
vtkm::Id,
vtkm::Id,
vtkm::cont::Token& token) const
{
// Note: we ignore the size of the domain because the randomly accessed
// array might not have the same size depending on how the user is using
// the array.
return ExecObjectType(array);
return ExecObjectType(array, token);
}
};
}

9
vtkm/cont/arg/TransportTagWholeArrayOut.h
View File

@ -52,14 +52,17 @@ struct Transport<vtkm::cont::arg::TransportTagWholeArrayOut, ContObjectType, Dev
using ExecObjectType = vtkm::exec::ExecutionWholeArray<ValueType, StorageTag, Device>;
template <typename InputDomainType>
VTKM_CONT ExecObjectType
operator()(ContObjectType& array, const InputDomainType&, vtkm::Id, vtkm::Id) const
VTKM_CONT ExecObjectType operator()(ContObjectType& array,
const InputDomainType&,
vtkm::Id,
vtkm::Id,
vtkm::cont::Token& token) const
{
// Note: we ignore the size of the domain because the randomly accessed
// array might not have the same size depending on how the user is using
// the array.
return ExecObjectType(array, array.GetNumberOfValues());
return ExecObjectType(array, array.GetNumberOfValues(), token);
}
};
}

4
vtkm/cont/arg/testing/UnitTestTransportArrayIn.cxx
View File

@ -58,8 +58,10 @@ struct TryArrayInType
vtkm::cont::arg::Transport<vtkm::cont::arg::TransportTagArrayIn, ArrayHandleType, Device>
transport;
vtkm::cont::Token token;
TestKernelIn<PortalType> kernel;
kernel.Portal = transport(handle, handle, ARRAY_SIZE, ARRAY_SIZE);
kernel.Portal = transport(handle, handle, ARRAY_SIZE, ARRAY_SIZE, token);
vtkm::cont::DeviceAdapterAlgorithm<Device>::Schedule(kernel, ARRAY_SIZE);
}

4
vtkm/cont/arg/testing/UnitTestTransportArrayInOut.cxx
View File

@ -56,8 +56,10 @@ struct TryArrayInOutType
vtkm::cont::arg::Transport<vtkm::cont::arg::TransportTagArrayInOut, ArrayHandleType, Device>
transport;
vtkm::cont::Token token;
TestKernelInOut<PortalType> kernel;
kernel.Portal = transport(handle, handle, ARRAY_SIZE, ARRAY_SIZE);
kernel.Portal = transport(handle, handle, ARRAY_SIZE, ARRAY_SIZE, token);
vtkm::cont::DeviceAdapterAlgorithm<Device>::Schedule(kernel, ARRAY_SIZE);

4
vtkm/cont/arg/testing/UnitTestTransportArrayOut.cxx
View File

@ -50,9 +50,11 @@ struct TryArrayOutType
vtkm::cont::arg::Transport<vtkm::cont::arg::TransportTagArrayOut, ArrayHandleType, Device>
transport;
vtkm::cont::Token token;
TestKernelOut<PortalType> kernel;
kernel.Portal =
transport(handle, vtkm::cont::ArrayHandleIndex(ARRAY_SIZE), ARRAY_SIZE, ARRAY_SIZE);
transport(handle, vtkm::cont::ArrayHandleIndex(ARRAY_SIZE), ARRAY_SIZE, ARRAY_SIZE, token);
VTKM_TEST_ASSERT(handle.GetNumberOfValues() == ARRAY_SIZE,
"ArrayOut transport did not allocate array correctly.");

4
vtkm/cont/arg/testing/UnitTestTransportCellSetIn.cxx
View File

@ -71,8 +71,10 @@ void TransportWholeCellSetIn(Device)
Device>
transport;
vtkm::cont::Token token;
TestKernel<ExecObjectType> kernel;
kernel.CellSet = transport(contObject, nullptr, 1, 1);
kernel.CellSet = transport(contObject, nullptr, 1, 1, token);
vtkm::cont::DeviceAdapterAlgorithm<Device>::Schedule(kernel, 1);
}

4
vtkm/cont/arg/testing/UnitTestTransportExecObject.cxx
View File

@ -73,8 +73,10 @@ void TryExecObjectTransport(Device)
vtkm::cont::arg::Transport<vtkm::cont::arg::TransportTagExecObject, TestExecutionObject, Device>
transport;
vtkm::cont::Token token;
TestKernel<Device> kernel;
kernel.Object = transport(contObject, nullptr, 1, 1);
kernel.Object = transport(contObject, nullptr, 1, 1, token);
vtkm::cont::DeviceAdapterAlgorithm<Device>::Schedule(kernel, 1);
}

16
vtkm/cont/arg/testing/UnitTestTransportWholeArray.cxx
View File

@ -123,25 +123,30 @@ struct TryWholeArrayType
ArrayHandleType array;
array.Allocate(ARRAY_SIZE);
vtkm::cont::Token token;
std::cout << "Check Transport WholeArrayOut" << std::endl;
TestOutKernel<typename OutTransportType::ExecObjectType> outKernel;
outKernel.Portal = OutTransportType()(array, nullptr, -1, -1);
outKernel.Portal = OutTransportType()(array, nullptr, -1, -1, token);
vtkm::cont::DeviceAdapterAlgorithm<Device>::Schedule(outKernel, ARRAY_SIZE);
token.DetachFromAll();
CheckPortal(array.GetPortalConstControl());
std::cout << "Check Transport WholeArrayIn" << std::endl;
TestInKernel<typename InTransportType::ExecObjectType> inKernel;
inKernel.Portal = InTransportType()(array, nullptr, -1, -1);
inKernel.Portal = InTransportType()(array, nullptr, -1, -1, token);
vtkm::cont::DeviceAdapterAlgorithm<Device>::Schedule(inKernel, ARRAY_SIZE);
token.DetachFromAll();
std::cout << "Check Transport WholeArrayInOut" << std::endl;
TestInOutKernel<typename InOutTransportType::ExecObjectType> inOutKernel;
inOutKernel.Portal = InOutTransportType()(array, nullptr, -1, -1);
inOutKernel.Portal = InOutTransportType()(array, nullptr, -1, -1, token);
vtkm::cont::DeviceAdapterAlgorithm<Device>::Schedule(inOutKernel, ARRAY_SIZE);
token.DetachFromAll();
VTKM_TEST_ASSERT(array.GetNumberOfValues() == ARRAY_SIZE, "Array size wrong?");
for (vtkm::Id index = 0; index < ARRAY_SIZE; index++)
@ -169,11 +174,14 @@ struct TryAtomicArrayType
array.Allocate(1);
array.GetPortalControl().Set(0, 0);
vtkm::cont::Token token;
std::cout << "Check Transport AtomicArray" << std::endl;
TestAtomicKernel<typename TransportType::ExecObjectType> kernel(
TransportType()(array, nullptr, -1, -1));
TransportType()(array, nullptr, -1, -1, token));
vtkm::cont::DeviceAdapterAlgorithm<Device>::Schedule(kernel, ARRAY_SIZE);
token.DetachFromAll();
T result = array.GetPortalConstControl().Get(0);
VTKM_TEST_ASSERT(result == ((ARRAY_SIZE - 1) * ARRAY_SIZE) / 2,

6
vtkm/cont/cuda/internal/ArrayManagerExecutionCuda.h
View File

@ -75,7 +75,7 @@ public:
vtkm::Id GetNumberOfValues() const { return static_cast<vtkm::Id>(this->End - this->Begin); }
VTKM_CONT
PortalConstType PrepareForInput(bool updateData)
PortalConstType PrepareForInput(bool updateData, vtkm::cont::Token&)
{
try
{
@ -99,7 +99,7 @@ public:
}
VTKM_CONT
PortalType PrepareForInPlace(bool updateData)
PortalType PrepareForInPlace(bool updateData, vtkm::cont::Token&)
{
try
{
@ -123,7 +123,7 @@ public:
}
VTKM_CONT
PortalType PrepareForOutput(vtkm::Id numberOfValues)
PortalType PrepareForOutput(vtkm::Id numberOfValues, vtkm::cont::Token&)
{
try
{

45
vtkm/cont/internal/ArrayHandleExecutionManager.h
View File

@ -12,6 +12,7 @@
#include <vtkm/cont/ErrorInternal.h>
#include <vtkm/cont/Storage.h>
#include <vtkm/cont/Token.h>
#include <vtkm/cont/internal/ArrayTransfer.h>
@ -68,13 +69,13 @@ public:
/// Returns a constant array portal valid in the execution environment.
///
template <typename DeviceAdapter>
VTKM_CONT typename ExecutionTypes<DeviceAdapter>::PortalConst PrepareForInput(bool updateData,
DeviceAdapter)
VTKM_CONT typename ExecutionTypes<DeviceAdapter>::PortalConst
PrepareForInput(bool updateData, DeviceAdapter, vtkm::cont::Token& token)
{
this->VerifyDeviceAdapter(DeviceAdapter());
typename ExecutionTypes<DeviceAdapter>::PortalConst portal;
this->PrepareForInputImpl(updateData, &portal);
this->PrepareForInputImpl(updateData, &portal, token);
return portal;
}
@ -85,13 +86,13 @@ public:
/// Returns a read-write array portal valid in the execution environment.
///
template <typename DeviceAdapter>
VTKM_CONT typename ExecutionTypes<DeviceAdapter>::Portal PrepareForInPlace(bool updateData,
DeviceAdapter)
VTKM_CONT typename ExecutionTypes<DeviceAdapter>::Portal
PrepareForInPlace(bool updateData, DeviceAdapter, vtkm::cont::Token& token)
{
this->VerifyDeviceAdapter(DeviceAdapter());
typename ExecutionTypes<DeviceAdapter>::Portal portal;
this->PrepareForInPlaceImpl(updateData, &portal);
this->PrepareForInPlaceImpl(updateData, &portal, token);
return portal;
}
@ -103,13 +104,13 @@ public:
/// Returns a writable array portal valid in the execution environment.
///
template <typename DeviceAdapter>
VTKM_CONT typename ExecutionTypes<DeviceAdapter>::Portal PrepareForOutput(vtkm::Id numberOfValues,
DeviceAdapter)
VTKM_CONT typename ExecutionTypes<DeviceAdapter>::Portal
PrepareForOutput(vtkm::Id numberOfValues, DeviceAdapter, vtkm::cont::Token& token)
{
this->VerifyDeviceAdapter(DeviceAdapter());
typename ExecutionTypes<DeviceAdapter>::Portal portal;
this->PrepareForOutputImpl(numberOfValues, &portal);
this->PrepareForOutputImpl(numberOfValues, &portal, token);
return portal;
}
@ -153,11 +154,17 @@ public:
protected:
virtual vtkm::Id GetNumberOfValuesImpl() const = 0;
virtual void PrepareForInputImpl(bool updateData, void* portalExecutionVoid) = 0;
virtual void PrepareForInputImpl(bool updateData,
void* portalExecutionVoid,
vtkm::cont::Token& token) = 0;
virtual void PrepareForInPlaceImpl(bool updateData, void* portalExecutionVoid) = 0;
virtual void PrepareForInPlaceImpl(bool updateData,
void* portalExecutionVoid,
vtkm::cont::Token& token) = 0;
virtual void PrepareForOutputImpl(vtkm::Id numberOfValues, void* portalExecution) = 0;
virtual void PrepareForOutputImpl(vtkm::Id numberOfValues,
void* portalExecution,
vtkm::cont::Token& token) = 0;
virtual void RetrieveOutputDataImpl(StorageType* storage) const = 0;
@ -212,23 +219,25 @@ protected:
vtkm::Id GetNumberOfValuesImpl() const { return this->Transfer.GetNumberOfValues(); }
VTKM_CONT
void PrepareForInputImpl(bool updateData, void* portalExecutionVoid)
void PrepareForInputImpl(bool updateData, void* portalExecutionVoid, vtkm::cont::Token& token)
{
PortalConstExecution portal = this->Transfer.PrepareForInput(updateData);
PortalConstExecution portal = this->Transfer.PrepareForInput(updateData, token);
*reinterpret_cast<PortalConstExecution*>(portalExecutionVoid) = portal;
}
VTKM_CONT
void PrepareForInPlaceImpl(bool updateData, void* portalExecutionVoid)
void PrepareForInPlaceImpl(bool updateData, void* portalExecutionVoid, vtkm::cont::Token& token)
{
PortalExecution portal = this->Transfer.PrepareForInPlace(updateData);
PortalExecution portal = this->Transfer.PrepareForInPlace(updateData, token);
*reinterpret_cast<PortalExecution*>(portalExecutionVoid) = portal;
}
VTKM_CONT
void PrepareForOutputImpl(vtkm::Id numberOfValues, void* portalExecutionVoid)
void PrepareForOutputImpl(vtkm::Id numberOfValues,
void* portalExecutionVoid,
vtkm::cont::Token& token)
{
PortalExecution portal = this->Transfer.PrepareForOutput(numberOfValues);
PortalExecution portal = this->Transfer.PrepareForOutput(numberOfValues, token);
*reinterpret_cast<PortalExecution*>(portalExecutionVoid) = portal;
}

9
vtkm/cont/internal/ArrayManagerExecutionShareWithControl.h
View File

@ -53,7 +53,7 @@ public:
/// Returns the constant portal from the storage.
///
VTKM_CONT
PortalConstType PrepareForInput(bool vtkmNotUsed(uploadData)) const
PortalConstType PrepareForInput(bool vtkmNotUsed(uploadData), vtkm::cont::Token&) const
{
return this->Storage->GetPortalConst();
}
@ -61,12 +61,15 @@ public:
/// Returns the read-write portal from the storage.
///
VTKM_CONT
PortalType PrepareForInPlace(bool vtkmNotUsed(uploadData)) { return this->Storage->GetPortal(); }
PortalType PrepareForInPlace(bool vtkmNotUsed(uploadData), vtkm::cont::Token&)
{
return this->Storage->GetPortal();
}
/// Allocates data in the storage and return the portal to that.
///
VTKM_CONT
PortalType PrepareForOutput(vtkm::Id numberOfValues)
PortalType PrepareForOutput(vtkm::Id numberOfValues, vtkm::cont::Token&)
{
this->Storage->Allocate(numberOfValues);
return this->Storage->GetPortal();

13
vtkm/cont/internal/ArrayTransfer.h
View File

@ -11,6 +11,7 @@
#define vtk_m_cont_internal_ArrayTransfer_h
#include <vtkm/cont/Storage.h>
#include <vtkm/cont/Token.h>
#include <vtkm/cont/internal/ArrayManagerExecution.h>
namespace vtkm
@ -78,9 +79,9 @@ public:
/// Returns a constant array portal valid in the execution environment.
///
VTKM_CONT
PortalConstExecution PrepareForInput(bool updateData)
PortalConstExecution PrepareForInput(bool updateData, vtkm::cont::Token& token)
{
return this->ArrayManager.PrepareForInput(updateData);
return this->ArrayManager.PrepareForInput(updateData, token);
}
/// Prepares the data for use as both input and output in the execution
@ -91,9 +92,9 @@ public:
/// Returns a read-write array portal valid in the execution environment.
///
VTKM_CONT
PortalExecution PrepareForInPlace(bool updateData)
PortalExecution PrepareForInPlace(bool updateData, vtkm::cont::Token& token)
{
return this->ArrayManager.PrepareForInPlace(updateData);
return this->ArrayManager.PrepareForInPlace(updateData, token);
}
/// Allocates an array in the execution environment of the specified size. If
@ -104,9 +105,9 @@ public:
/// Returns a writable array portal valid in the execution environment.
///
VTKM_CONT
PortalExecution PrepareForOutput(vtkm::Id numberOfValues)
PortalExecution PrepareForOutput(vtkm::Id numberOfValues, vtkm::cont::Token& token)
{
return this->ArrayManager.PrepareForOutput(numberOfValues);
return this->ArrayManager.PrepareForOutput(numberOfValues, token);
}
/// Allocates data in the given Storage and copies data held in the execution

20
vtkm/cont/internal/testing/UnitTestArrayManagerExecutionShareWithControl.cxx
View File

@ -58,7 +58,8 @@ struct TemplatedTests
bool CheckManager(ArrayManagerType& manager, const ValueType& value)
{
return CheckPortal(manager.PrepareForInput(false), value);
vtkm::cont::Token token;
return CheckPortal(manager.PrepareForInput(false, token), value);
}
void InputData()
@ -71,11 +72,14 @@ struct TemplatedTests
ArrayManagerType executionArray(&storage);
vtkm::cont::Token token;
// Although the ArrayManagerExecutionShareWithControl class wraps the
// control array portal in a different array portal, it should still
// give the same iterator (to avoid any unnecessary indirection).
VTKM_TEST_ASSERT(vtkm::cont::ArrayPortalToIteratorBegin(storage.GetPortalConst()) ==
vtkm::cont::ArrayPortalToIteratorBegin(executionArray.PrepareForInput(true)),
VTKM_TEST_ASSERT(
vtkm::cont::ArrayPortalToIteratorBegin(storage.GetPortalConst()) ==
vtkm::cont::ArrayPortalToIteratorBegin(executionArray.PrepareForInput(true, token)),
"Execution array manager not holding control array iterators.");
VTKM_TEST_ASSERT(CheckManager(executionArray, INPUT_VALUE), "Did not get correct array back.");
@ -91,16 +95,18 @@ struct TemplatedTests
ArrayManagerType executionArray(&storage);
vtkm::cont::Token token;
// Although the ArrayManagerExecutionShareWithControl class wraps the
// control array portal in a different array portal, it should still
// give the same iterator (to avoid any unnecessary indirection).
VTKM_TEST_ASSERT(
vtkm::cont::ArrayPortalToIteratorBegin(storage.GetPortal()) ==
vtkm::cont::ArrayPortalToIteratorBegin(executionArray.PrepareForInPlace(true)),
vtkm::cont::ArrayPortalToIteratorBegin(executionArray.PrepareForInPlace(true, token)),
"Execution array manager not holding control array iterators.");
VTKM_TEST_ASSERT(
vtkm::cont::ArrayPortalToIteratorBegin(storage.GetPortalConst()) ==
vtkm::cont::ArrayPortalToIteratorBegin(executionArray.PrepareForInput(false)),
vtkm::cont::ArrayPortalToIteratorBegin(executionArray.PrepareForInput(false, token)),
"Execution array manager not holding control array iterators.");
VTKM_TEST_ASSERT(CheckManager(executionArray, INPUT_VALUE), "Did not get correct array back.");
@ -114,8 +120,10 @@ struct TemplatedTests
ArrayManagerType executionArray(&storage);
vtkm::cont::Token token;
vtkm::cont::ArrayPortalToIterators<typename ArrayManagerType::PortalType> iterators(
executionArray.PrepareForOutput(ARRAY_SIZE));
executionArray.PrepareForOutput(ARRAY_SIZE, token));
std::fill(iterators.GetBegin(), iterators.GetEnd(), OUTPUT_VALUE);
VTKM_TEST_ASSERT(CheckManager(executionArray, OUTPUT_VALUE), "Did not get correct array back.");

12
vtkm/cont/openmp/internal/ArrayManagerExecutionOpenMP.h
View File

@ -44,21 +44,21 @@ public:
}
VTKM_CONT
PortalConstType PrepareForInput(bool updateData)
PortalConstType PrepareForInput(bool updateData, vtkm::cont::Token& token)
{
return this->Superclass::PrepareForInput(updateData);
return this->Superclass::PrepareForInput(updateData, token);
}
VTKM_CONT
PortalType PrepareForInPlace(bool updateData)
PortalType PrepareForInPlace(bool updateData, vtkm::cont::Token& token)
{
return this->Superclass::PrepareForInPlace(updateData);
return this->Superclass::PrepareForInPlace(updateData, token);
}
VTKM_CONT
PortalType PrepareForOutput(vtkm::Id numberOfValues)
PortalType PrepareForOutput(vtkm::Id numberOfValues, vtkm::cont::Token& token)
{
return this->Superclass::PrepareForOutput(numberOfValues);
return this->Superclass::PrepareForOutput(numberOfValues, token);
}
};

12
vtkm/cont/tbb/internal/ArrayManagerExecutionTBB.h
View File

@ -45,21 +45,21 @@ public:
}
VTKM_CONT
PortalConstType PrepareForInput(bool updateData)
PortalConstType PrepareForInput(bool updateData, vtkm::cont::Token& token)
{
return this->Superclass::PrepareForInput(updateData);
return this->Superclass::PrepareForInput(updateData, token);
}
VTKM_CONT
PortalType PrepareForInPlace(bool updateData)
PortalType PrepareForInPlace(bool updateData, vtkm::cont::Token& token)
{
return this->Superclass::PrepareForInPlace(updateData);
return this->Superclass::PrepareForInPlace(updateData, token);
}
VTKM_CONT
PortalType PrepareForOutput(vtkm::Id numberOfValues)
PortalType PrepareForOutput(vtkm::Id numberOfValues, vtkm::cont::Token& token)
{
return this->Superclass::PrepareForOutput(numberOfValues);
return this->Superclass::PrepareForOutput(numberOfValues, token);
}
};

11
vtkm/exec/AtomicArrayExecutionObject.h
View File

@ -69,6 +69,7 @@ public:
AtomicArrayExecutionObject() = default;
// This constructor is deprecated in VTK-m 1.6.
VTKM_CONT AtomicArrayExecutionObject(vtkm::cont::ArrayHandle<T> handle)
: Data{ handle.PrepareForInPlace(Device{}).GetIteratorBegin() }
, NumberOfValues{ handle.GetNumberOfValues() }
@ -79,6 +80,16 @@ public:
"GetIteratorBegin().");
}
VTKM_CONT AtomicArrayExecutionObject(vtkm::cont::ArrayHandle<T> handle, vtkm::cont::Token& token)
: Data{ handle.PrepareForInPlace(Device{}, token).GetIteratorBegin() }
, NumberOfValues{ handle.GetNumberOfValues() }
{
using PortalType = decltype(handle.PrepareForInPlace(Device{}, token));
VTKM_STATIC_ASSERT_MSG(HasPointerAccess<PortalType>::value,
"Source portal must return a pointer from "
"GetIteratorBegin().");
}
VTKM_SUPPRESS_EXEC_WARNINGS
VTKM_EXEC
vtkm::Id GetNumberOfValues() const { return this->NumberOfValues; }

21
vtkm/exec/ExecutionWholeArray.h
View File

@ -41,18 +41,32 @@ public:
{
}
// This constructor is deprecated in VTK-m 1.6
VTKM_CONT
ExecutionWholeArray(HandleType& handle)
: Portal(handle.PrepareForInPlace(DeviceAdapterTag()))
{
}
// This constructor is deprecated in VTK-m 1.6
VTKM_CONT
ExecutionWholeArray(HandleType& handle, vtkm::Id length)
: Portal(handle.PrepareForOutput(length, DeviceAdapterTag()))
{
}
VTKM_CONT
ExecutionWholeArray(HandleType& handle, vtkm::cont::Token& token)
: Portal(handle.PrepareForInPlace(DeviceAdapterTag(), token))
{
}
VTKM_CONT
ExecutionWholeArray(HandleType& handle, vtkm::Id length, vtkm::cont::Token& token)
: Portal(handle.PrepareForOutput(length, DeviceAdapterTag(), token))
{
}
VTKM_EXEC
vtkm::Id GetNumberOfValues() const { return this->Portal.GetNumberOfValues(); }
@ -91,12 +105,19 @@ public:
{
}
// This constructor is deprecated in VTK-m 1.6
VTKM_CONT
ExecutionWholeArrayConst(const HandleType& handle)
: Portal(handle.PrepareForInput(DeviceAdapterTag()))
{
}
VTKM_CONT
ExecutionWholeArrayConst(const HandleType& handle, vtkm::cont::Token& token)
: Portal(handle.PrepareForInput(DeviceAdapterTag(), token))
{
}
VTKM_EXEC
vtkm::Id GetNumberOfValues() const { return this->Portal.GetNumberOfValues(); }

4
vtkm/worklet/DispatcherStreamingMapField.h
View File

@ -284,8 +284,10 @@ private:
using ExecObjectParameters =
typename ParameterInterfaceType::template StaticTransformType<TransportFunctorType>::type;
vtkm::cont::Token token;
ExecObjectParameters execObjectParameters = parameters.StaticTransformCont(
TransportFunctorType(invocation.GetInputDomain(), inputRange, outputRange));
TransportFunctorType(invocation.GetInputDomain(), inputRange, outputRange, token));
// Get the arrays used for scattering input to output.
typename ScatterType::OutputToInputMapType outputToInputMap =

42
vtkm/worklet/Keys.h
View File

@ -141,12 +141,22 @@ public:
};
template <typename Device>
VTKM_CONT typename ExecutionTypes<Device>::Lookup PrepareForInput(Device) const
VTKM_CONT typename ExecutionTypes<Device>::Lookup PrepareForInput(Device device,
vtkm::cont::Token& token) const
{
return typename ExecutionTypes<Device>::Lookup(this->UniqueKeys.PrepareForInput(Device()),
this->SortedValuesMap.PrepareForInput(Device()),
this->Offsets.PrepareForInput(Device()),
this->Counts.PrepareForInput(Device()));
return
typename ExecutionTypes<Device>::Lookup(this->UniqueKeys.PrepareForInput(device, token),
this->SortedValuesMap.PrepareForInput(device, token),
this->Offsets.PrepareForInput(device, token),
this->Counts.PrepareForInput(device, token));
}
template <typename Device>
VTKM_CONT VTKM_DEPRECATED(1.6, "PrepareForInput now requires a vtkm::cont::Token object.")
typename ExecutionTypes<Device>::Lookup PrepareForInput(Device device) const
{
vtkm::cont::Token token;
return this->PrepareForInput(device, token);
}
VTKM_CONT
@ -221,14 +231,15 @@ struct Transport<vtkm::cont::arg::TransportTagKeysIn, vtkm::worklet::Keys<KeyTyp
ExecObjectType operator()(const ContObjectType& object,
const ContObjectType& inputDomain,
vtkm::Id,
vtkm::Id) const
vtkm::Id,
vtkm::cont::Token& token) const
{
if (object != inputDomain)
{
throw vtkm::cont::ErrorBadValue("A Keys object must be the input domain.");
}
return object.PrepareForInput(Device());
return object.PrepareForInput(Device(), token);
}
// If you get a compile error here, it means that you have used a KeysIn
@ -255,7 +266,8 @@ struct Transport<vtkm::cont::arg::TransportTagKeyedValuesIn, ArrayHandleType, De
VTKM_CONT ExecObjectType operator()(const ContObjectType& object,
const vtkm::worklet::Keys<KeyType>& keys,
vtkm::Id,
vtkm::Id) const
vtkm::Id,
vtkm::cont::Token& token) const
{
if (object.GetNumberOfValues() != keys.GetNumberOfValues())
{
@ -269,7 +281,7 @@ struct Transport<vtkm::cont::arg::TransportTagKeyedValuesIn, ArrayHandleType, De
// maintaining the resources it points to. However, the entire state of the
// portal should be self contained except for the data managed by the
// object argument, which should stay in scope.
return groupedArray.PrepareForInput(Device());
return groupedArray.PrepareForInput(Device(), token);
}
};
@ -290,7 +302,8 @@ struct Transport<vtkm::cont::arg::TransportTagKeyedValuesInOut, ArrayHandleType,
VTKM_CONT ExecObjectType operator()(ContObjectType object,
const vtkm::worklet::Keys<KeyType>& keys,
vtkm::Id,
vtkm::Id) const
vtkm::Id,
vtkm::cont::Token& token) const
{
if (object.GetNumberOfValues() != keys.GetNumberOfValues())
{
@ -304,7 +317,7 @@ struct Transport<vtkm::cont::arg::TransportTagKeyedValuesInOut, ArrayHandleType,
// maintaining the resources it points to. However, the entire state of the
// portal should be self contained except for the data managed by the
// object argument, which should stay in scope.
return groupedArray.PrepareForInPlace(Device());
return groupedArray.PrepareForInPlace(Device(), token);
}
};
@ -325,12 +338,13 @@ struct Transport<vtkm::cont::arg::TransportTagKeyedValuesOut, ArrayHandleType, D
VTKM_CONT ExecObjectType operator()(ContObjectType object,
const vtkm::worklet::Keys<KeyType>& keys,
vtkm::Id,
vtkm::Id) const
vtkm::Id,
vtkm::cont::Token& token) const
{
// The PrepareForOutput for ArrayHandleGroupVecVariable and
// ArrayHandlePermutation cannot determine the actual size expected for the
// target array (object), so we have to make sure it gets allocated here.
object.PrepareForOutput(keys.GetNumberOfValues(), Device());
object.PrepareForOutput(keys.GetNumberOfValues(), Device(), token);
PermutedArrayType permutedArray(keys.GetSortedValuesMap(), object);
GroupedArrayType groupedArray(permutedArray, keys.GetOffsets());
@ -339,7 +353,7 @@ struct Transport<vtkm::cont::arg::TransportTagKeyedValuesOut, ArrayHandleType, D
// maintaining the resources it points to. However, the entire state of the
// portal should be self contained except for the data managed by the
// object argument, which should stay in scope.
return groupedArray.PrepareForOutput(keys.GetInputRange(), Device());
return groupedArray.PrepareForOutput(keys.GetInputRange(), Device(), token);
}
};
}

43
vtkm/worklet/gradient/GradientOutput.h
View File

@ -42,9 +42,11 @@ struct GradientScalarOutputExecutionObject
GradientScalarOutputExecutionObject() = default;
GradientScalarOutputExecutionObject(vtkm::cont::ArrayHandle<ValueType> gradient, vtkm::Id size)
GradientScalarOutputExecutionObject(vtkm::cont::ArrayHandle<ValueType> gradient,
vtkm::Id size,
vtkm::cont::Token& token)
{
this->GradientPortal = gradient.PrepareForOutput(size, DeviceAdapter());
this->GradientPortal = gradient.PrepareForOutput(size, DeviceAdapter(), token);
}
VTKM_SUPPRESS_EXEC_WARNINGS
@ -65,9 +67,11 @@ struct GradientScalarOutput : public vtkm::cont::ExecutionObjectBase
template <typename Device>
VTKM_CONT vtkm::exec::GradientScalarOutputExecutionObject<T, Device> PrepareForExecution(
Device) const
Device,
vtkm::cont::Token& token) const
{
return vtkm::exec::GradientScalarOutputExecutionObject<T, Device>(this->Gradient, this->Size);
return vtkm::exec::GradientScalarOutputExecutionObject<T, Device>(
this->Gradient, this->Size, token);
}
GradientScalarOutput() = default;
@ -113,7 +117,8 @@ struct GradientVecOutputExecutionObject
vtkm::cont::ArrayHandle<BaseTType> divergence,
vtkm::cont::ArrayHandle<vtkm::Vec<BaseTType, 3>> vorticity,
vtkm::cont::ArrayHandle<BaseTType> qcriterion,
vtkm::Id size)
vtkm::Id size,
vtkm::cont::Token& token)
{
this->SetGradient = g;
this->SetDivergence = d;
@ -123,19 +128,19 @@ struct GradientVecOutputExecutionObject
DeviceAdapter device;
if (g)
{
this->GradientPortal = gradient.PrepareForOutput(size, device);
this->GradientPortal = gradient.PrepareForOutput(size, device, token);
}
if (d)
{
this->DivergencePortal = divergence.PrepareForOutput(size, device);
this->DivergencePortal = divergence.PrepareForOutput(size, device, token);
}
if (v)
{
this->VorticityPortal = vorticity.PrepareForOutput(size, device);
this->VorticityPortal = vorticity.PrepareForOutput(size, device, token);
}
if (q)
{
this->QCriterionPortal = qcriterion.PrepareForOutput(size, device);
this->QCriterionPortal = qcriterion.PrepareForOutput(size, device, token);
}
}
@ -189,7 +194,8 @@ struct GradientVecOutput : public vtkm::cont::ExecutionObjectBase
template <typename Device>
VTKM_CONT vtkm::exec::GradientVecOutputExecutionObject<T, Device> PrepareForExecution(
Device) const
Device,
vtkm::cont::Token& token) const
{
return vtkm::exec::GradientVecOutputExecutionObject<T, Device>(this->G,
this->D,
@ -199,7 +205,8 @@ struct GradientVecOutput : public vtkm::cont::ExecutionObjectBase
this->Divergence,
this->Vorticity,
this->Qcriterion,
this->Size);
this->Size,
token);
}
GradientVecOutput() = default;
@ -276,18 +283,20 @@ struct TransportTagGradientOut
template <typename ContObjectType, typename Device>
struct Transport<vtkm::cont::arg::TransportTagGradientOut, ContObjectType, Device>
{
using ExecObjectFacotryType = vtkm::exec::GradientOutput<typename ContObjectType::ValueType>;
using ExecObjectType =
decltype(std::declval<ExecObjectFacotryType>().PrepareForExecution(Device()));
using ExecObjectFactoryType = vtkm::exec::GradientOutput<typename ContObjectType::ValueType>;
using ExecObjectType = decltype(
std::declval<ExecObjectFactoryType>().PrepareForExecution(Device(),
std::declval<vtkm::cont::Token&>()));
template <typename InputDomainType>
VTKM_CONT ExecObjectType operator()(ContObjectType object,
const InputDomainType& vtkmNotUsed(inputDomain),
vtkm::Id vtkmNotUsed(inputRange),
vtkm::Id outputRange) const
vtkm::Id outputRange,
vtkm::cont::Token& token) const
{
ExecObjectFacotryType ExecutionObjectFacotry = object.PrepareForOutput(outputRange);
return ExecutionObjectFacotry.PrepareForExecution(Device());
ExecObjectFactoryType ExecutionObjectFactory = object.PrepareForOutput(outputRange);
return ExecutionObjectFactory.PrepareForExecution(Device(), token);
}
};
}

18
vtkm/worklet/internal/DispatcherBase.h
View File

@ -288,6 +288,7 @@ struct DispatcherBaseTransportFunctor
const InputDomainType& InputDomain; // Warning: this is a reference
vtkm::Id InputRange;
vtkm::Id OutputRange;
vtkm::cont::Token& Token; // Warning: this is a reference
// TODO: We need to think harder about how scheduling on 3D arrays works.
// Chances are we need to allow the transport for each argument to manage
@ -296,10 +297,12 @@ struct DispatcherBaseTransportFunctor
template <typename InputRangeType, typename OutputRangeType>
VTKM_CONT DispatcherBaseTransportFunctor(const InputDomainType& inputDomain,
const InputRangeType& inputRange,
const OutputRangeType& outputRange)
const OutputRangeType& outputRange,
vtkm::cont::Token& token)
: InputDomain(inputDomain)
, InputRange(FlatRange(inputRange))
, OutputRange(FlatRange(outputRange))
, Token(token)
{
}
@ -325,8 +328,11 @@ struct DispatcherBaseTransportFunctor
vtkm::cont::arg::Transport<TransportTag, T, Device> transport;
not_nullptr(invokeData, Index);
return transport(
as_ref(invokeData), as_ref(this->InputDomain), this->InputRange, this->OutputRange);
return transport(as_ref(invokeData),
as_ref(this->InputDomain),
this->InputRange,
this->OutputRange,
this->Token);
}
@ -710,6 +716,10 @@ private:
ThreadRangeType&& threadRange,
DeviceAdapter device) const
{
// This token represents the scope of the execution objects. It should
// exist as long as things run on the device.
vtkm::cont::Token token;
// The first step in invoking a worklet is to transport the arguments to
// the execution environment. The invocation object passed to this function
// contains the parameters passed to Invoke in the control environment. We
@ -730,7 +740,7 @@ private:
typename ParameterInterfaceType::template StaticTransformType<TransportFunctorType>::type;
ExecObjectParameters execObjectParameters = parameters.StaticTransformCont(
TransportFunctorType(invocation.GetInputDomain(), inputRange, outputRange));
TransportFunctorType(invocation.GetInputDomain(), inputRange, outputRange, token));
// Get the arrays used for scattering input to output.
typename ScatterType::OutputToInputMapType outputToInputMap =

6
vtkm/worklet/internal/testing/UnitTestDispatcherBase.cxx
View File

@ -125,7 +125,8 @@ struct Transport<TestTransportTagIn, std::vector<vtkm::Id>, Device>
ExecObjectType operator()(const std::vector<vtkm::Id>& contData,
const std::vector<vtkm::Id>&,
vtkm::Id inputRange,
vtkm::Id outputRange) const
vtkm::Id outputRange,
vtkm::cont::Token&) const
{
VTKM_TEST_ASSERT(inputRange == ARRAY_SIZE, "Got unexpected size in test transport.");
VTKM_TEST_ASSERT(outputRange == ARRAY_SIZE, "Got unexpected size in test transport.");
@ -142,7 +143,8 @@ struct Transport<TestTransportTagOut, std::vector<vtkm::Id>, Device>
ExecObjectType operator()(const std::vector<vtkm::Id>& contData,
const std::vector<vtkm::Id>&,
vtkm::Id inputRange,
vtkm::Id outputRange) const
vtkm::Id outputRange,
vtkm::cont::Token&) const
{
VTKM_TEST_ASSERT(inputRange == ARRAY_SIZE, "Got unexpected size in test transport.");
VTKM_TEST_ASSERT(outputRange == ARRAY_SIZE, "Got unexpected size in test transport.");