Shuenhoy/vtk-m
1
0
Fork 0
mirror of https://gitlab.kitware.com/vtk/vtk-m synced 2024-09-19 18:45:43 +00:00
Code Issues 2 Actions Packages Projects Releases Wiki Activity
5482bc5518
vtk-m/vtkm/internal/Invocation.h

428 lines
17 KiB
C
Raw Normal View History

Add Fetch class The Fetch class is responsible for moving data in and out of some collection in the execution environment. The Fetch class is templated with a pair of tags (the type of fetch and the aspect) that control the mechanism used for the fetch.
2014-10-15 19:52:27 +00:00
//============================================================================
// Copyright (c) Kitware, Inc.
// All rights reserved.
// See LICENSE.txt for details.
conslidate the license statement
2019-04-15 23:24:21 +00:00
//
Add Fetch class The Fetch class is responsible for moving data in and out of some collection in the execution environment. The Fetch class is templated with a pair of tags (the type of fetch and the aspect) that control the mechanism used for the fetch.
2014-10-15 19:52:27 +00:00
// This software is distributed WITHOUT ANY WARRANTY; without even
// the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
// PURPOSE. See the above copyright notice for more information.
//============================================================================
#ifndef vtk_m_internal_Invocation_h
#define vtk_m_internal_Invocation_h
#include <vtkm/Types.h>
Another round of simplifications to FunctionInterface Yet more ways that we can reduce the complexity of `FunctionInterface`. This is another step in figuring out what set of features the replacement for `FunctionInterface` needs to have.
2019-12-03 18:30:43 +00:00
#include <vtkm/internal/FunctionInterface.h>
Add Fetch class The Fetch class is responsible for moving data in and out of some collection in the execution environment. The Fetch class is templated with a pair of tags (the type of fetch and the aspect) that control the mechanism used for the fetch.
2014-10-15 19:52:27 +00:00
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
namespace vtkm
{
namespace internal
{
Add Fetch class The Fetch class is responsible for moving data in and out of some collection in the execution environment. The Fetch class is templated with a pair of tags (the type of fetch and the aspect) that control the mechanism used for the fetch.
2014-10-15 19:52:27 +00:00
/// \brief Container for types when dispatching worklets.
///
/// When a dispatcher and associated class invoke a worklet, they need to keep
/// track of the types of all parameters and the associated features of the
/// worklet. \c Invocation is a class that manages all these types.
///
VTK-m now doesn't use reserved C++ identifiers Fixes #340
2019-02-28 20:08:08 +00:00
template <typename ParameterInterface_,
typename ControlInterface_,
typename ExecutionInterface_,
vtkm::IdComponent InputDomainIndex_,
typename OutputToInputMapType_ = vtkm::internal::NullType,
typename VisitArrayType_ = vtkm::internal::NullType,
Add ability to specialize worklet for device This adds an ExecutionSignature tag named Device that passes the DeviceAdapterTag as an argument to the worklet's operator(). This allows worklets to specialize their code based on the device.
2019-03-08 01:32:56 +00:00
typename ThreadToOutputMapType_ = vtkm::internal::NullType,
typename DeviceAdapterTag_ = vtkm::internal::NullType>
Add Fetch class The Fetch class is responsible for moving data in and out of some collection in the execution environment. The Fetch class is templated with a pair of tags (the type of fetch and the aspect) that control the mechanism used for the fetch.
2014-10-15 19:52:27 +00:00
struct Invocation
{
/// \brief The types of the parameters
///
Add basic dispatcher functionality. These changes support the implementation of DispatcherBase. This class provides the basic functionality for calling an Invoke method in the control environment, transferring data to the execution environment, scheduling threads in the execution environment, pulling data for each calling of the worklet method, and actually calling the worklet.
2014-10-21 16:51:07 +00:00
/// \c ParameterInterface is (expected to be) a \c FunctionInterface class
/// that lists the types of the parameters for the invocation.
Add Fetch class The Fetch class is responsible for moving data in and out of some collection in the execution environment. The Fetch class is templated with a pair of tags (the type of fetch and the aspect) that control the mechanism used for the fetch.
2014-10-15 19:52:27 +00:00
///
VTK-m now doesn't use reserved C++ identifiers Fixes #340
2019-02-28 20:08:08 +00:00
using ParameterInterface = ParameterInterface_;
Add Fetch class The Fetch class is responsible for moving data in and out of some collection in the execution environment. The Fetch class is templated with a pair of tags (the type of fetch and the aspect) that control the mechanism used for the fetch.
2014-10-15 19:52:27 +00:00
Add basic dispatcher functionality. These changes support the implementation of DispatcherBase. This class provides the basic functionality for calling an Invoke method in the control environment, transferring data to the execution environment, scheduling threads in the execution environment, pulling data for each calling of the worklet method, and actually calling the worklet.
2014-10-21 16:51:07 +00:00
/// \brief The tags of the \c ControlSignature.
///
/// \c ControlInterface is (expected to be) a \c FunctionInterface class that
/// represents the \c ControlSignature of a worklet (although dispatchers
/// might modify the control signature to provide auxiliary information).
///
VTK-m now doesn't use reserved C++ identifiers Fixes #340
2019-02-28 20:08:08 +00:00
using ControlInterface = ControlInterface_;
Add basic dispatcher functionality. These changes support the implementation of DispatcherBase. This class provides the basic functionality for calling an Invoke method in the control environment, transferring data to the execution environment, scheduling threads in the execution environment, pulling data for each calling of the worklet method, and actually calling the worklet.
2014-10-21 16:51:07 +00:00
/// \brief The tags of the \c ExecutionSignature.
///
/// \c ExecutionInterface is (expected to be) a \c FunctionInterface class that
/// represents the \c ExecutionSignature of a worklet (although dispatchers
/// might modify the execution signature to provide auxiliary information).
///
VTK-m now doesn't use reserved C++ identifiers Fixes #340
2019-02-28 20:08:08 +00:00
using ExecutionInterface = ExecutionInterface_;
Add basic dispatcher functionality. These changes support the implementation of DispatcherBase. This class provides the basic functionality for calling an Invoke method in the control environment, transferring data to the execution environment, scheduling threads in the execution environment, pulling data for each calling of the worklet method, and actually calling the worklet.
2014-10-21 16:51:07 +00:00
Add Fetch class The Fetch class is responsible for moving data in and out of some collection in the execution environment. The Fetch class is templated with a pair of tags (the type of fetch and the aspect) that control the mechanism used for the fetch.
2014-10-15 19:52:27 +00:00
/// \brief The index of the input domain.
///
/// When a worklet is invoked, the pool of working threads is based of some
/// constituent element of the input (such as the points or cells). This
/// index points to the parameter that defines this input domain.
///
VTK-m now doesn't use reserved C++ identifiers Fixes #340
2019-02-28 20:08:08 +00:00
static constexpr vtkm::IdComponent InputDomainIndex = InputDomainIndex_;
Add Fetch class The Fetch class is responsible for moving data in and out of some collection in the execution environment. The Fetch class is templated with a pair of tags (the type of fetch and the aspect) that control the mechanism used for the fetch.
2014-10-15 19:52:27 +00:00
Add Scatter parameters to Invocation. We are passing in execution objects with the Invocation when the Worklet is scheduled, but we are not using it yet.
2015-09-22 04:35:13 +00:00
/// \brief An array representing the output to input map.
///
/// When a worklet is invoked, there is an optional scatter operation that
/// allows you to vary the number of outputs each input affects. This is
/// represented with a map where each output points to an input that creates
/// it.
///
VTK-m now doesn't use reserved C++ identifiers Fixes #340
2019-02-28 20:08:08 +00:00
using OutputToInputMapType = OutputToInputMapType_;
Add Scatter parameters to Invocation. We are passing in execution objects with the Invocation when the Worklet is scheduled, but we are not using it yet.
2015-09-22 04:35:13 +00:00
/// \brief An array containing visit indices.
///
/// When a worklet is invoked, there is an optinonal scatter operation that
/// allows you to vary the number of outputs each input affects. Thus,
/// multiple outputs may point to the same input. The visit index uniquely
/// identifies which instance each is.
///
VTK-m now doesn't use reserved C++ identifiers Fixes #340
2019-02-28 20:08:08 +00:00
using VisitArrayType = VisitArrayType_;
Add Scatter parameters to Invocation. We are passing in execution objects with the Invocation when the Worklet is scheduled, but we are not using it yet.
2015-09-22 04:35:13 +00:00
Add Mask capabilities to worklets Mask objects allow you to specify which output values should be generated when a worklet is run. That is, the Mask allows you to skip the invocation of a worklet for any number of outputs.
2019-01-21 02:14:55 +00:00
/// \brief An array representing the thread to output map.
///
/// When a worklet is invoked, there is an optional mask operation that will
/// prevent the worklet to be run on masked-out elements of the output. This
/// is represented with a map where each thread points to an output it creates.
///
VTK-m now doesn't use reserved C++ identifiers Fixes #340
2019-02-28 20:08:08 +00:00
using ThreadToOutputMapType = ThreadToOutputMapType_;
Add Mask capabilities to worklets Mask objects allow you to specify which output values should be generated when a worklet is run. That is, the Mask allows you to skip the invocation of a worklet for any number of outputs.
2019-01-21 02:14:55 +00:00
Add ability to specialize worklet for device This adds an ExecutionSignature tag named Device that passes the DeviceAdapterTag as an argument to the worklet's operator(). This allows worklets to specialize their code based on the device.
2019-03-08 01:32:56 +00:00
/// \brief The tag for the device adapter on which the worklet is run.
///
/// When the worklet is dispatched on a particular device, this type in the
/// Invocation is set to the tag associated with that device.
///
using DeviceAdapterTag = DeviceAdapterTag_;
Perform less unnecessary copies when deducing a worklets parameters. One of the causes of the large library size and slow compile times has been that vtkm has been creating unnecessary copies when not needed. When the objects being copied use shared_ptr this causes a bloom in library size. I presume this bloom is caused by the atomic increment/decrement that is required by shared_ptr. For testing I used the following example: ``` struct ExampleFieldWorklet : public vtkm::worklet::WorkletMapField { typedef void ControlSignature( FieldIn<>, FieldIn<>, FieldIn<>, FieldOut<>, FieldOut<>, FieldOut<> ); typedef void ExecutionSignature( _1, _2, _3, _4, _5, _6 ); template<typename T, typename U, typename V> VTKM_EXEC_EXPORT void operator()( const vtkm::Vec< T, 3 > & vec, const U & scalar1, const V& scalar2, vtkm::Vec<T, 3>& out_vec, U& out_scalar1, V& out_scalar2 ) const { out_vec = vec * scalar1; out_scalar1 = scalar1 + scalar2; out_scalar2 = scalar2; } template<typename T, typename U, typename V, typename W, typename X, typename Y> VTKM_EXEC_EXPORT void operator()( const T & vec, const U & scalar1, const V& scalar2, W& out_vec, X& out_scalar, Y& ) const { //no-op } }; int main(int argc, char** argv) { std::vector< vtkm::Vec<vtkm::Float32, 3> > inputVec; std::vector< vtkm::Int32 > inputScalar1; std::vector< vtkm::Float64 > inputScalar2; vtkm::cont::ArrayHandle< vtkm::Vec<vtkm::Float32, 3> > handleV = vtkm::cont::make_ArrayHandle(inputVec); vtkm::cont::ArrayHandle< vtkm::Vec<vtkm::Float32, 3> > handleS1 = vtkm::cont::make_ArrayHandle(inputVec); vtkm::cont::ArrayHandle< vtkm::Vec<vtkm::Float32, 3> > handleS2 = vtkm::cont::make_ArrayHandle(inputVec); vtkm::cont::ArrayHandle< vtkm::Vec<vtkm::Float32, 3> > handleOV; vtkm::cont::ArrayHandle< vtkm::Vec<vtkm::Float32, 3> > handleOS1; vtkm::cont::ArrayHandle< vtkm::Vec<vtkm::Float32, 3> > handleOS2; std::cout << "Making 3 output DynamicArrayHandles " << std::endl; vtkm::cont::DynamicArrayHandle out1(handleOV), out2(handleOS1), out3(handleOS2); typedef vtkm::worklet::DispatcherMapField<ExampleFieldWorklet> DispatcherType; std::cout << "Invoking ExampleFieldWorklet" << std::endl; DispatcherType dispatcher; dispatcher.Invoke(handleV, handleS1, handleS2, out1, out2, out3); } ``` Original vtkm would generate a binary of size 4684kb and would perform 91 ArrayHandle copies or assignments. With this branch the binary size is reduced to 2392kb and will perform 36 copies or assignments.
2016-01-15 22:14:02 +00:00
/// \brief Default Invocation constructors that holds the given parameters
/// by reference.
Remove exports for header-only functions/methods Change the VTKM_CONT_EXPORT to VTKM_CONT. (Likewise for EXEC and EXEC_CONT.) Remove the inline from these macros so that they can be applied to everything, including implementations in a library. Because inline is not declared in these modifies, you have to add the keyword to functions and methods where the implementation is not inlined in the class.
2016-10-19 22:42:58 +00:00
VTKM_CONT
Perform less unnecessary copies when deducing a worklets parameters. One of the causes of the large library size and slow compile times has been that vtkm has been creating unnecessary copies when not needed. When the objects being copied use shared_ptr this causes a bloom in library size. I presume this bloom is caused by the atomic increment/decrement that is required by shared_ptr. For testing I used the following example: ``` struct ExampleFieldWorklet : public vtkm::worklet::WorkletMapField { typedef void ControlSignature( FieldIn<>, FieldIn<>, FieldIn<>, FieldOut<>, FieldOut<>, FieldOut<> ); typedef void ExecutionSignature( _1, _2, _3, _4, _5, _6 ); template<typename T, typename U, typename V> VTKM_EXEC_EXPORT void operator()( const vtkm::Vec< T, 3 > & vec, const U & scalar1, const V& scalar2, vtkm::Vec<T, 3>& out_vec, U& out_scalar1, V& out_scalar2 ) const { out_vec = vec * scalar1; out_scalar1 = scalar1 + scalar2; out_scalar2 = scalar2; } template<typename T, typename U, typename V, typename W, typename X, typename Y> VTKM_EXEC_EXPORT void operator()( const T & vec, const U & scalar1, const V& scalar2, W& out_vec, X& out_scalar, Y& ) const { //no-op } }; int main(int argc, char** argv) { std::vector< vtkm::Vec<vtkm::Float32, 3> > inputVec; std::vector< vtkm::Int32 > inputScalar1; std::vector< vtkm::Float64 > inputScalar2; vtkm::cont::ArrayHandle< vtkm::Vec<vtkm::Float32, 3> > handleV = vtkm::cont::make_ArrayHandle(inputVec); vtkm::cont::ArrayHandle< vtkm::Vec<vtkm::Float32, 3> > handleS1 = vtkm::cont::make_ArrayHandle(inputVec); vtkm::cont::ArrayHandle< vtkm::Vec<vtkm::Float32, 3> > handleS2 = vtkm::cont::make_ArrayHandle(inputVec); vtkm::cont::ArrayHandle< vtkm::Vec<vtkm::Float32, 3> > handleOV; vtkm::cont::ArrayHandle< vtkm::Vec<vtkm::Float32, 3> > handleOS1; vtkm::cont::ArrayHandle< vtkm::Vec<vtkm::Float32, 3> > handleOS2; std::cout << "Making 3 output DynamicArrayHandles " << std::endl; vtkm::cont::DynamicArrayHandle out1(handleOV), out2(handleOS1), out3(handleOS2); typedef vtkm::worklet::DispatcherMapField<ExampleFieldWorklet> DispatcherType; std::cout << "Invoking ExampleFieldWorklet" << std::endl; DispatcherType dispatcher; dispatcher.Invoke(handleV, handleS1, handleS2, out1, out2, out3); } ``` Original vtkm would generate a binary of size 4684kb and would perform 91 ArrayHandle copies or assignments. With this branch the binary size is reduced to 2392kb and will perform 36 copies or assignments.
2016-01-15 22:14:02 +00:00
Invocation(const ParameterInterface& parameters,
Add Scatter parameters to Invocation. We are passing in execution objects with the Invocation when the Worklet is scheduled, but we are not using it yet.
2015-09-22 04:35:13 +00:00
OutputToInputMapType outputToInputMap = OutputToInputMapType(),
Add Mask capabilities to worklets Mask objects allow you to specify which output values should be generated when a worklet is run. That is, the Mask allows you to skip the invocation of a worklet for any number of outputs.
2019-01-21 02:14:55 +00:00
VisitArrayType visitArray = VisitArrayType(),
ThreadToOutputMapType threadToOutputMap = ThreadToOutputMapType())
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
: Parameters(parameters)
, OutputToInputMap(outputToInputMap)
, VisitArray(visitArray)
Add Mask capabilities to worklets Mask objects allow you to specify which output values should be generated when a worklet is run. That is, the Mask allows you to skip the invocation of a worklet for any number of outputs.
2019-01-21 02:14:55 +00:00
, ThreadToOutputMap(threadToOutputMap)
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
{
}
Add Fetch class The Fetch class is responsible for moving data in and out of some collection in the execution environment. The Fetch class is templated with a pair of tags (the type of fetch and the aspect) that control the mechanism used for the fetch.
2014-10-15 19:52:27 +00:00
Correct warnings found with CUDA 10.2 + gcc 4.8.5 Found during building on Centos7 based Power9 machines
2020-02-26 20:16:35 +00:00
Invocation(const Invocation&) = default;
Add missing constructors/assignment operators Having a custom assignment operator means that the compiler isn't required to generate the implicit copy constructor. This makes sure they are constructed.
2020-01-13 20:54:59 +00:00
Add Fetch class The Fetch class is responsible for moving data in and out of some collection in the execution environment. The Fetch class is templated with a pair of tags (the type of fetch and the aspect) that control the mechanism used for the fetch.
2014-10-15 19:52:27 +00:00
/// Defines a new \c Invocation type that is the same as this type except
/// with the \c Parameters replaced.
///
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
template <typename NewParameterInterface>
struct ChangeParametersType
{
Convert VTK-m over to use 'using' instead of 'typedef'
2017-06-23 18:50:34 +00:00
using type = Invocation<NewParameterInterface,
ControlInterface,
ExecutionInterface,
InputDomainIndex,
OutputToInputMapType,
Add Mask capabilities to worklets Mask objects allow you to specify which output values should be generated when a worklet is run. That is, the Mask allows you to skip the invocation of a worklet for any number of outputs.
2019-01-21 02:14:55 +00:00
VisitArrayType,
Add ability to specialize worklet for device This adds an ExecutionSignature tag named Device that passes the DeviceAdapterTag as an argument to the worklet's operator(). This allows worklets to specialize their code based on the device.
2019-03-08 01:32:56 +00:00
ThreadToOutputMapType,
DeviceAdapterTag>;
Add Fetch class The Fetch class is responsible for moving data in and out of some collection in the execution environment. The Fetch class is templated with a pair of tags (the type of fetch and the aspect) that control the mechanism used for the fetch.
2014-10-15 19:52:27 +00:00
};
/// Returns a new \c Invocation that is the same as this one except that the
Add basic dispatcher functionality. These changes support the implementation of DispatcherBase. This class provides the basic functionality for calling an Invoke method in the control environment, transferring data to the execution environment, scheduling threads in the execution environment, pulling data for each calling of the worklet method, and actually calling the worklet.
2014-10-21 16:51:07 +00:00
/// \c Parameters are replaced with those provided.
Add Fetch class The Fetch class is responsible for moving data in and out of some collection in the execution environment. The Fetch class is templated with a pair of tags (the type of fetch and the aspect) that control the mechanism used for the fetch.
2014-10-15 19:52:27 +00:00
///
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
template <typename NewParameterInterface>
VTKM_CONT typename ChangeParametersType<NewParameterInterface>::type ChangeParameters(
const NewParameterInterface& newParameters) const
{
Add Fetch class The Fetch class is responsible for moving data in and out of some collection in the execution environment. The Fetch class is templated with a pair of tags (the type of fetch and the aspect) that control the mechanism used for the fetch.
2014-10-15 19:52:27 +00:00
return typename ChangeParametersType<NewParameterInterface>::type(
Add Mask capabilities to worklets Mask objects allow you to specify which output values should be generated when a worklet is run. That is, the Mask allows you to skip the invocation of a worklet for any number of outputs.
2019-01-21 02:14:55 +00:00
newParameters, this->OutputToInputMap, this->VisitArray, this->ThreadToOutputMap);
Add Fetch class The Fetch class is responsible for moving data in and out of some collection in the execution environment. The Fetch class is templated with a pair of tags (the type of fetch and the aspect) that control the mechanism used for the fetch.
2014-10-15 19:52:27 +00:00
}
Add basic dispatcher functionality. These changes support the implementation of DispatcherBase. This class provides the basic functionality for calling an Invoke method in the control environment, transferring data to the execution environment, scheduling threads in the execution environment, pulling data for each calling of the worklet method, and actually calling the worklet.
2014-10-21 16:51:07 +00:00
/// Defines a new \c Invocation type that is the same as this type except
/// with the \c ControlInterface replaced.
///
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
template <typename NewControlInterface>
struct ChangeControlInterfaceType
{
Add Mask capabilities to worklets Mask objects allow you to specify which output values should be generated when a worklet is run. That is, the Mask allows you to skip the invocation of a worklet for any number of outputs.
2019-01-21 02:14:55 +00:00
using type = Invocation<ParameterInterface,
NewControlInterface,
ExecutionInterface,
InputDomainIndex,
OutputToInputMapType,
VisitArrayType,
Add ability to specialize worklet for device This adds an ExecutionSignature tag named Device that passes the DeviceAdapterTag as an argument to the worklet's operator(). This allows worklets to specialize their code based on the device.
2019-03-08 01:32:56 +00:00
ThreadToOutputMapType,
DeviceAdapterTag>;
Add basic dispatcher functionality. These changes support the implementation of DispatcherBase. This class provides the basic functionality for calling an Invoke method in the control environment, transferring data to the execution environment, scheduling threads in the execution environment, pulling data for each calling of the worklet method, and actually calling the worklet.
2014-10-21 16:51:07 +00:00
};
/// Returns a new \c Invocation that is the same as this one except that the
/// \c ControlInterface type is changed to the type given.
///
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
template <typename NewControlInterface>
typename ChangeControlInterfaceType<NewControlInterface>::type ChangeControlInterface(
NewControlInterface) const
{
Add basic dispatcher functionality. These changes support the implementation of DispatcherBase. This class provides the basic functionality for calling an Invoke method in the control environment, transferring data to the execution environment, scheduling threads in the execution environment, pulling data for each calling of the worklet method, and actually calling the worklet.
2014-10-21 16:51:07 +00:00
return typename ChangeControlInterfaceType<NewControlInterface>::type(
Add Mask capabilities to worklets Mask objects allow you to specify which output values should be generated when a worklet is run. That is, the Mask allows you to skip the invocation of a worklet for any number of outputs.
2019-01-21 02:14:55 +00:00
this->Parameters, this->OutputToInputMap, this->VisitArray, this->ThreadToOutputMap);
Add basic dispatcher functionality. These changes support the implementation of DispatcherBase. This class provides the basic functionality for calling an Invoke method in the control environment, transferring data to the execution environment, scheduling threads in the execution environment, pulling data for each calling of the worklet method, and actually calling the worklet.
2014-10-21 16:51:07 +00:00
}
/// Defines a new \c Invocation type that is the same as this type except
/// with the \c ExecutionInterface replaced.
///
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
template <typename NewExecutionInterface>
struct ChangeExecutionInterfaceType
{
Add Mask capabilities to worklets Mask objects allow you to specify which output values should be generated when a worklet is run. That is, the Mask allows you to skip the invocation of a worklet for any number of outputs.
2019-01-21 02:14:55 +00:00
using type = Invocation<ParameterInterface,
NewExecutionInterface,
ExecutionInterface,
InputDomainIndex,
OutputToInputMapType,
VisitArrayType,
Add ability to specialize worklet for device This adds an ExecutionSignature tag named Device that passes the DeviceAdapterTag as an argument to the worklet's operator(). This allows worklets to specialize their code based on the device.
2019-03-08 01:32:56 +00:00
ThreadToOutputMapType,
DeviceAdapterTag>;
Add basic dispatcher functionality. These changes support the implementation of DispatcherBase. This class provides the basic functionality for calling an Invoke method in the control environment, transferring data to the execution environment, scheduling threads in the execution environment, pulling data for each calling of the worklet method, and actually calling the worklet.
2014-10-21 16:51:07 +00:00
};
/// Returns a new \c Invocation that is the same as this one except that the
/// \c ExecutionInterface type is changed to the type given.
///
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
template <typename NewExecutionInterface>
typename ChangeExecutionInterfaceType<NewExecutionInterface>::type ChangeExecutionInterface(
NewExecutionInterface) const
{
Add basic dispatcher functionality. These changes support the implementation of DispatcherBase. This class provides the basic functionality for calling an Invoke method in the control environment, transferring data to the execution environment, scheduling threads in the execution environment, pulling data for each calling of the worklet method, and actually calling the worklet.
2014-10-21 16:51:07 +00:00
return typename ChangeExecutionInterfaceType<NewExecutionInterface>::type(
Add Mask capabilities to worklets Mask objects allow you to specify which output values should be generated when a worklet is run. That is, the Mask allows you to skip the invocation of a worklet for any number of outputs.
2019-01-21 02:14:55 +00:00
this->Parameters, this->OutputToInputMap, this->VisitArray, this->ThreadToOutputMap);
Add basic dispatcher functionality. These changes support the implementation of DispatcherBase. This class provides the basic functionality for calling an Invoke method in the control environment, transferring data to the execution environment, scheduling threads in the execution environment, pulling data for each calling of the worklet method, and actually calling the worklet.
2014-10-21 16:51:07 +00:00
}
Add Fetch class The Fetch class is responsible for moving data in and out of some collection in the execution environment. The Fetch class is templated with a pair of tags (the type of fetch and the aspect) that control the mechanism used for the fetch.
2014-10-15 19:52:27 +00:00
/// Defines a new \c Invocation type that is the same as this type except
/// with the \c InputDomainIndex replaced.
///
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
template <vtkm::IdComponent NewInputDomainIndex>
struct ChangeInputDomainIndexType
{
Add Mask capabilities to worklets Mask objects allow you to specify which output values should be generated when a worklet is run. That is, the Mask allows you to skip the invocation of a worklet for any number of outputs.
2019-01-21 02:14:55 +00:00
using type = Invocation<ParameterInterface,
ControlInterface,
ExecutionInterface,
NewInputDomainIndex,
OutputToInputMapType,
VisitArrayType,
Add ability to specialize worklet for device This adds an ExecutionSignature tag named Device that passes the DeviceAdapterTag as an argument to the worklet's operator(). This allows worklets to specialize their code based on the device.
2019-03-08 01:32:56 +00:00
ThreadToOutputMapType,
DeviceAdapterTag>;
Add Fetch class The Fetch class is responsible for moving data in and out of some collection in the execution environment. The Fetch class is templated with a pair of tags (the type of fetch and the aspect) that control the mechanism used for the fetch.
2014-10-15 19:52:27 +00:00
};
/// Returns a new \c Invocation that is the same as this one except that the
/// \c InputDomainIndex is changed to the static number given.
///
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
template <vtkm::IdComponent NewInputDomainIndex>
VTKM_EXEC_CONT typename ChangeInputDomainIndexType<NewInputDomainIndex>::type
ChangeInputDomainIndex() const
{
Add Fetch class The Fetch class is responsible for moving data in and out of some collection in the execution environment. The Fetch class is templated with a pair of tags (the type of fetch and the aspect) that control the mechanism used for the fetch.
2014-10-15 19:52:27 +00:00
return typename ChangeInputDomainIndexType<NewInputDomainIndex>::type(
Add Mask capabilities to worklets Mask objects allow you to specify which output values should be generated when a worklet is run. That is, the Mask allows you to skip the invocation of a worklet for any number of outputs.
2019-01-21 02:14:55 +00:00
this->Parameters, this->OutputToInputMap, this->VisitArray, this->ThreadToOutputMap);
Add Scatter parameters to Invocation. We are passing in execution objects with the Invocation when the Worklet is scheduled, but we are not using it yet.
2015-09-22 04:35:13 +00:00
}
/// Defines a new \c Invocation type that is the same as this type except
/// with the \c OutputToInputMapType replaced.
///
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
template <typename NewOutputToInputMapType>
struct ChangeOutputToInputMapType
{
Convert VTK-m over to use 'using' instead of 'typedef'
2017-06-23 18:50:34 +00:00
using type = Invocation<ParameterInterface,
ControlInterface,
ExecutionInterface,
InputDomainIndex,
NewOutputToInputMapType,
Add Mask capabilities to worklets Mask objects allow you to specify which output values should be generated when a worklet is run. That is, the Mask allows you to skip the invocation of a worklet for any number of outputs.
2019-01-21 02:14:55 +00:00
VisitArrayType,
Add ability to specialize worklet for device This adds an ExecutionSignature tag named Device that passes the DeviceAdapterTag as an argument to the worklet's operator(). This allows worklets to specialize their code based on the device.
2019-03-08 01:32:56 +00:00
ThreadToOutputMapType,
DeviceAdapterTag>;
Add Scatter parameters to Invocation. We are passing in execution objects with the Invocation when the Worklet is scheduled, but we are not using it yet.
2015-09-22 04:35:13 +00:00
};
/// Returns a new \c Invocation that is the same as this one except that the
/// \c OutputToInputMap is replaced with that provided.
///
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
template <typename NewOutputToInputMapType>
VTKM_CONT typename ChangeOutputToInputMapType<NewOutputToInputMapType>::type
ChangeOutputToInputMap(NewOutputToInputMapType newOutputToInputMap) const
{
Add Scatter parameters to Invocation. We are passing in execution objects with the Invocation when the Worklet is scheduled, but we are not using it yet.
2015-09-22 04:35:13 +00:00
return typename ChangeOutputToInputMapType<NewOutputToInputMapType>::type(
Add Mask capabilities to worklets Mask objects allow you to specify which output values should be generated when a worklet is run. That is, the Mask allows you to skip the invocation of a worklet for any number of outputs.
2019-01-21 02:14:55 +00:00
this->Parameters, newOutputToInputMap, this->VisitArray, this->ThreadToOutputMap);
Add Scatter parameters to Invocation. We are passing in execution objects with the Invocation when the Worklet is scheduled, but we are not using it yet.
2015-09-22 04:35:13 +00:00
}
/// Defines a new \c Invocation type that is the same as this type except
/// with the \c VisitArrayType replaced.
///
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
template <typename NewVisitArrayType>
struct ChangeVisitArrayType
{
Convert VTK-m over to use 'using' instead of 'typedef'
2017-06-23 18:50:34 +00:00
using type = Invocation<ParameterInterface,
ControlInterface,
ExecutionInterface,
InputDomainIndex,
OutputToInputMapType,
Add Mask capabilities to worklets Mask objects allow you to specify which output values should be generated when a worklet is run. That is, the Mask allows you to skip the invocation of a worklet for any number of outputs.
2019-01-21 02:14:55 +00:00
NewVisitArrayType,
Add ability to specialize worklet for device This adds an ExecutionSignature tag named Device that passes the DeviceAdapterTag as an argument to the worklet's operator(). This allows worklets to specialize their code based on the device.
2019-03-08 01:32:56 +00:00
ThreadToOutputMapType,
DeviceAdapterTag>;
Add Scatter parameters to Invocation. We are passing in execution objects with the Invocation when the Worklet is scheduled, but we are not using it yet.
2015-09-22 04:35:13 +00:00
};
/// Returns a new \c Invocation that is the same as this one except that the
/// \c VisitArray is replaced with that provided.
///
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
template <typename NewVisitArrayType>
VTKM_CONT typename ChangeVisitArrayType<NewVisitArrayType>::type ChangeVisitArray(
NewVisitArrayType newVisitArray) const
{
Add Scatter parameters to Invocation. We are passing in execution objects with the Invocation when the Worklet is scheduled, but we are not using it yet.
2015-09-22 04:35:13 +00:00
return typename ChangeVisitArrayType<NewVisitArrayType>::type(
Add Mask capabilities to worklets Mask objects allow you to specify which output values should be generated when a worklet is run. That is, the Mask allows you to skip the invocation of a worklet for any number of outputs.
2019-01-21 02:14:55 +00:00
this->Parameters, this->OutputToInputMap, newVisitArray, this->ThreadToOutputMap);
}
/// Defines a new \c Invocation type that is the same as this type except
/// with the \c ThreadToOutputMapType replaced.
///
template <typename NewThreadToOutputMapType>
struct ChangeThreadToOutputMapType
{
using type = Invocation<ParameterInterface,
ControlInterface,
ExecutionInterface,
InputDomainIndex,
OutputToInputMapType,
VisitArrayType,
Add ability to specialize worklet for device This adds an ExecutionSignature tag named Device that passes the DeviceAdapterTag as an argument to the worklet's operator(). This allows worklets to specialize their code based on the device.
2019-03-08 01:32:56 +00:00
NewThreadToOutputMapType,
DeviceAdapterTag>;
Add Mask capabilities to worklets Mask objects allow you to specify which output values should be generated when a worklet is run. That is, the Mask allows you to skip the invocation of a worklet for any number of outputs.
2019-01-21 02:14:55 +00:00
};
/// Returns a new \c Invocation that is the same as this one except that the
/// \c OutputToInputMap is replaced with that provided.
///
template <typename NewThreadToOutputMapType>
VTKM_CONT typename ChangeThreadToOutputMapType<NewThreadToOutputMapType>::type
ChangeThreadToOutputMap(NewThreadToOutputMapType newThreadToOutputMap) const
{
return typename ChangeThreadToOutputMapType<NewThreadToOutputMapType>::type(
this->Parameters, this->OutputToInputMap, this->VisitArray, newThreadToOutputMap);
Add Fetch class The Fetch class is responsible for moving data in and out of some collection in the execution environment. The Fetch class is templated with a pair of tags (the type of fetch and the aspect) that control the mechanism used for the fetch.
2014-10-15 19:52:27 +00:00
}
Change Fetches to use ThreadIndices instead of Invocation. Previously, all Fetch objects received an Invocation object in their Load and Store methods. The point of this was that it allowed the Fetch to get data from any of the execution objects. However, every Fetch either just got data directly from its associated execution object or else used a secondary execution object (the input domain) to get indices into their own execution object. This left two potential areas for improvement. First, pulling data out of the Invocation object was unnecessarily complicated. It would be much nicer to get data directly from the associated execution object. Second, when getting index information from the input domain, it was often the case that extra computations were necessary (particularly on structured cell sets). There was no way to share the index information among Fetches, and therefore the computations were replicated. This change removes the Invocation from the Fetch Load and Store. Instead, it passes the associated execution object and a new object type called the ThreadIndices. The ThreadIndices are customized for the input domain and therefore have all the information needed for a redirected lookup. It is also a thread-local object so it can cache computed indices and save on computation time.
2015-10-07 18:14:00 +00:00
Add ability to specialize worklet for device This adds an ExecutionSignature tag named Device that passes the DeviceAdapterTag as an argument to the worklet's operator(). This allows worklets to specialize their code based on the device.
2019-03-08 01:32:56 +00:00
/// Defines a new \c Invocation type that is the same as this type except
/// with the \c DeviceAdapterTag replaced.
///
template <typename NewDeviceAdapterTag>
struct ChangeDeviceAdapterTagType
{
using type = Invocation<ParameterInterface,
ControlInterface,
ExecutionInterface,
InputDomainIndex,
OutputToInputMapType,
VisitArrayType,
ThreadToOutputMapType,
NewDeviceAdapterTag>;
};
/// Returns a new \c Invocation that is the same as this one except that the
/// \c DeviceAdapterTag is replaced with that provided.
///
template <typename NewDeviceAdapterTag>
VTKM_CONT typename ChangeDeviceAdapterTagType<NewDeviceAdapterTag>::type ChangeDeviceAdapterTag(
NewDeviceAdapterTag) const
{
return typename ChangeDeviceAdapterTagType<NewDeviceAdapterTag>::type(
this->Parameters, this->OutputToInputMap, this->VisitArray, this->ThreadToOutputMap);
}
Convert VTK-m over to use 'using' instead of 'typedef'
2017-06-23 18:50:34 +00:00
/// A convenience alias for the input domain type.
Change Fetches to use ThreadIndices instead of Invocation. Previously, all Fetch objects received an Invocation object in their Load and Store methods. The point of this was that it allowed the Fetch to get data from any of the execution objects. However, every Fetch either just got data directly from its associated execution object or else used a secondary execution object (the input domain) to get indices into their own execution object. This left two potential areas for improvement. First, pulling data out of the Invocation object was unnecessarily complicated. It would be much nicer to get data directly from the associated execution object. Second, when getting index information from the input domain, it was often the case that extra computations were necessary (particularly on structured cell sets). There was no way to share the index information among Fetches, and therefore the computations were replicated. This change removes the Invocation from the Fetch Load and Store. Instead, it passes the associated execution object and a new object type called the ThreadIndices. The ThreadIndices are customized for the input domain and therefore have all the information needed for a redirected lookup. It is also a thread-local object so it can cache computed indices and save on computation time.
2015-10-07 18:14:00 +00:00
///
Add InputDomainTag to Invocation
2017-03-04 03:12:20 +00:00
using InputDomainType =
typename ParameterInterface::template ParameterType<InputDomainIndex>::type;
Convert VTK-m over to use 'using' instead of 'typedef'
2017-06-23 18:50:34 +00:00
/// A convenience alias for the control signature tag of the input domain.
Add InputDomainTag to Invocation
2017-03-04 03:12:20 +00:00
///
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
using InputDomainTag = typename ControlInterface::template ParameterType<InputDomainIndex>::type;
Change Fetches to use ThreadIndices instead of Invocation. Previously, all Fetch objects received an Invocation object in their Load and Store methods. The point of this was that it allowed the Fetch to get data from any of the execution objects. However, every Fetch either just got data directly from its associated execution object or else used a secondary execution object (the input domain) to get indices into their own execution object. This left two potential areas for improvement. First, pulling data out of the Invocation object was unnecessarily complicated. It would be much nicer to get data directly from the associated execution object. Second, when getting index information from the input domain, it was often the case that extra computations were necessary (particularly on structured cell sets). There was no way to share the index information among Fetches, and therefore the computations were replicated. This change removes the Invocation from the Fetch Load and Store. Instead, it passes the associated execution object and a new object type called the ThreadIndices. The ThreadIndices are customized for the input domain and therefore have all the information needed for a redirected lookup. It is also a thread-local object so it can cache computed indices and save on computation time.
2015-10-07 18:14:00 +00:00
/// A convenience method to get the input domain object.
///
VTKM_SUPPRESS_EXEC_WARNINGS
Remove exports for header-only functions/methods Change the VTKM_CONT_EXPORT to VTKM_CONT. (Likewise for EXEC and EXEC_CONT.) Remove the inline from these macros so that they can be applied to everything, including implementations in a library. Because inline is not declared in these modifies, you have to add the keyword to functions and methods where the implementation is not inlined in the class.
2016-10-19 22:42:58 +00:00
VTKM_EXEC_CONT
Perform less unnecessary copies when deducing a worklets parameters. One of the causes of the large library size and slow compile times has been that vtkm has been creating unnecessary copies when not needed. When the objects being copied use shared_ptr this causes a bloom in library size. I presume this bloom is caused by the atomic increment/decrement that is required by shared_ptr. For testing I used the following example: ``` struct ExampleFieldWorklet : public vtkm::worklet::WorkletMapField { typedef void ControlSignature( FieldIn<>, FieldIn<>, FieldIn<>, FieldOut<>, FieldOut<>, FieldOut<> ); typedef void ExecutionSignature( _1, _2, _3, _4, _5, _6 ); template<typename T, typename U, typename V> VTKM_EXEC_EXPORT void operator()( const vtkm::Vec< T, 3 > & vec, const U & scalar1, const V& scalar2, vtkm::Vec<T, 3>& out_vec, U& out_scalar1, V& out_scalar2 ) const { out_vec = vec * scalar1; out_scalar1 = scalar1 + scalar2; out_scalar2 = scalar2; } template<typename T, typename U, typename V, typename W, typename X, typename Y> VTKM_EXEC_EXPORT void operator()( const T & vec, const U & scalar1, const V& scalar2, W& out_vec, X& out_scalar, Y& ) const { //no-op } }; int main(int argc, char** argv) { std::vector< vtkm::Vec<vtkm::Float32, 3> > inputVec; std::vector< vtkm::Int32 > inputScalar1; std::vector< vtkm::Float64 > inputScalar2; vtkm::cont::ArrayHandle< vtkm::Vec<vtkm::Float32, 3> > handleV = vtkm::cont::make_ArrayHandle(inputVec); vtkm::cont::ArrayHandle< vtkm::Vec<vtkm::Float32, 3> > handleS1 = vtkm::cont::make_ArrayHandle(inputVec); vtkm::cont::ArrayHandle< vtkm::Vec<vtkm::Float32, 3> > handleS2 = vtkm::cont::make_ArrayHandle(inputVec); vtkm::cont::ArrayHandle< vtkm::Vec<vtkm::Float32, 3> > handleOV; vtkm::cont::ArrayHandle< vtkm::Vec<vtkm::Float32, 3> > handleOS1; vtkm::cont::ArrayHandle< vtkm::Vec<vtkm::Float32, 3> > handleOS2; std::cout << "Making 3 output DynamicArrayHandles " << std::endl; vtkm::cont::DynamicArrayHandle out1(handleOV), out2(handleOS1), out3(handleOS2); typedef vtkm::worklet::DispatcherMapField<ExampleFieldWorklet> DispatcherType; std::cout << "Invoking ExampleFieldWorklet" << std::endl; DispatcherType dispatcher; dispatcher.Invoke(handleV, handleS1, handleS2, out1, out2, out3); } ``` Original vtkm would generate a binary of size 4684kb and would perform 91 ArrayHandle copies or assignments. With this branch the binary size is reduced to 2392kb and will perform 36 copies or assignments.
2016-01-15 22:14:02 +00:00
const InputDomainType& GetInputDomain() const
Change Fetches to use ThreadIndices instead of Invocation. Previously, all Fetch objects received an Invocation object in their Load and Store methods. The point of this was that it allowed the Fetch to get data from any of the execution objects. However, every Fetch either just got data directly from its associated execution object or else used a secondary execution object (the input domain) to get indices into their own execution object. This left two potential areas for improvement. First, pulling data out of the Invocation object was unnecessarily complicated. It would be much nicer to get data directly from the associated execution object. Second, when getting index information from the input domain, it was often the case that extra computations were necessary (particularly on structured cell sets). There was no way to share the index information among Fetches, and therefore the computations were replicated. This change removes the Invocation from the Fetch Load and Store. Instead, it passes the associated execution object and a new object type called the ThreadIndices. The ThreadIndices are customized for the input domain and therefore have all the information needed for a redirected lookup. It is also a thread-local object so it can cache computed indices and save on computation time.
2015-10-07 18:14:00 +00:00
{
Another round of simplifications to FunctionInterface Yet more ways that we can reduce the complexity of `FunctionInterface`. This is another step in figuring out what set of features the replacement for `FunctionInterface` needs to have.
2019-12-03 18:30:43 +00:00
return vtkm::internal::ParameterGet<InputDomainIndex>(this->Parameters);
Change Fetches to use ThreadIndices instead of Invocation. Previously, all Fetch objects received an Invocation object in their Load and Store methods. The point of this was that it allowed the Fetch to get data from any of the execution objects. However, every Fetch either just got data directly from its associated execution object or else used a secondary execution object (the input domain) to get indices into their own execution object. This left two potential areas for improvement. First, pulling data out of the Invocation object was unnecessarily complicated. It would be much nicer to get data directly from the associated execution object. Second, when getting index information from the input domain, it was often the case that extra computations were necessary (particularly on structured cell sets). There was no way to share the index information among Fetches, and therefore the computations were replicated. This change removes the Invocation from the Fetch Load and Store. Instead, it passes the associated execution object and a new object type called the ThreadIndices. The ThreadIndices are customized for the input domain and therefore have all the information needed for a redirected lookup. It is also a thread-local object so it can cache computed indices and save on computation time.
2015-10-07 18:14:00 +00:00
}
Add Fetch class The Fetch class is responsible for moving data in and out of some collection in the execution environment. The Fetch class is templated with a pair of tags (the type of fetch and the aspect) that control the mechanism used for the fetch.
2014-10-15 19:52:27 +00:00
/// The state of an \c Invocation object holds the parameters of the
Add Scatter parameters to Invocation. We are passing in execution objects with the Invocation when the Worklet is scheduled, but we are not using it yet.
2015-09-22 04:35:13 +00:00
/// invocation. As well as the output to input map and the visit array.
Add Fetch class The Fetch class is responsible for moving data in and out of some collection in the execution environment. The Fetch class is templated with a pair of tags (the type of fetch and the aspect) that control the mechanism used for the fetch.
2014-10-15 19:52:27 +00:00
///
Perform necessary copies when deducing a worklets parameters. As part of the work to reduce the number of copies of array handles the CUDA backend was broken. The transportation of stack allocated classes to CUDA relies on all member variables being value based, not references/pointers. This correct the issue of sending references to host side memory to CUDA, at the cost of two copies of the Invocation object. When we move to C++11 we need to revisit this work and see if std::move can help reduce the cost of these copies.
2016-01-26 20:08:46 +00:00
/// This is held by by value so that when we transfer the invocation object
/// over to CUDA it gets properly copied to the device. While we want to
/// hold by reference to reduce the number of copies, it is not possible
/// currently.
Invocation parameters are now non const and can be 'modified' The invocation parameters need to be non const as we want to be able to call non-const methods like `PrepareForOutput` on them from a transport function. The original implementation abused the fact that everything could be copied by value and have that work properly. But when we start introducing virtual classes copying by value of a base type can cause type slicing.
2018-07-02 18:28:58 +00:00
ParameterInterface Parameters;
Add Scatter parameters to Invocation. We are passing in execution objects with the Invocation when the Worklet is scheduled, but we are not using it yet.
2015-09-22 04:35:13 +00:00
OutputToInputMapType OutputToInputMap;
VisitArrayType VisitArray;
Add Mask capabilities to worklets Mask objects allow you to specify which output values should be generated when a worklet is run. That is, the Mask allows you to skip the invocation of a worklet for any number of outputs.
2019-01-21 02:14:55 +00:00
ThreadToOutputMapType ThreadToOutputMap;
Fix warnings about assignment operators not being generated For some reason when VTK-m was being compiled as an accelerator in VTK, Visual Studio 2013 gave a bunch of warnings about not being able to generate assignment operators for many classes. This happened for classes with a const ivar that could not be automatically set. (Automatic copy constructors are fine on this count.) I'm not sure why these warnings did not happen when just compiling VTK-m, nor am I sure why they were generated at all as no code actually used the copy constructors. This commit fixes the problems by adding a private declaration for assignment operators that cannot be automatically created. No implementation is provided, nor should any be needed.
2017-01-10 18:10:38 +00:00
private:
// Do not allow assignment of one Invocation to another. It is too expensive.
Respect VTK-m convention of parameters all or nothing on a line clang-format BinPack settings have been disabled to make sure that the VTK-m style guideline is obeyed.
2017-05-26 17:53:28 +00:00
void operator=(const Invocation<ParameterInterface,
ControlInterface,
ExecutionInterface,
InputDomainIndex,
OutputToInputMapType,
Add Mask capabilities to worklets Mask objects allow you to specify which output values should be generated when a worklet is run. That is, the Mask allows you to skip the invocation of a worklet for any number of outputs.
2019-01-21 02:14:55 +00:00
VisitArrayType,
Add ability to specialize worklet for device This adds an ExecutionSignature tag named Device that passes the DeviceAdapterTag as an argument to the worklet's operator(). This allows worklets to specialize their code based on the device.
2019-03-08 01:32:56 +00:00
ThreadToOutputMapType,
DeviceAdapterTag>&) = delete;
Add Fetch class The Fetch class is responsible for moving data in and out of some collection in the execution environment. The Fetch class is templated with a pair of tags (the type of fetch and the aspect) that control the mechanism used for the fetch.
2014-10-15 19:52:27 +00:00
};
/// Convenience function for creating an Invocation object.
///
Respect VTK-m convention of parameters all or nothing on a line clang-format BinPack settings have been disabled to make sure that the VTK-m style guideline is obeyed.
2017-05-26 17:53:28 +00:00
template <vtkm::IdComponent InputDomainIndex,
typename ControlInterface,
typename ExecutionInterface,
typename ParameterInterface,
typename OutputToInputMapType,
Add Mask capabilities to worklets Mask objects allow you to specify which output values should be generated when a worklet is run. That is, the Mask allows you to skip the invocation of a worklet for any number of outputs.
2019-01-21 02:14:55 +00:00
typename VisitArrayType,
typename ThreadToOutputMapType>
Respect VTK-m convention of parameters all or nothing on a line clang-format BinPack settings have been disabled to make sure that the VTK-m style guideline is obeyed.
2017-05-26 17:53:28 +00:00
VTKM_CONT vtkm::internal::Invocation<ParameterInterface,
ControlInterface,
ExecutionInterface,
InputDomainIndex,
OutputToInputMapType,
Add Mask capabilities to worklets Mask objects allow you to specify which output values should be generated when a worklet is run. That is, the Mask allows you to skip the invocation of a worklet for any number of outputs.
2019-01-21 02:14:55 +00:00
VisitArrayType,
ThreadToOutputMapType>
Respect VTK-m convention of parameters all or nothing on a line clang-format BinPack settings have been disabled to make sure that the VTK-m style guideline is obeyed.
2017-05-26 17:53:28 +00:00
make_Invocation(const ParameterInterface& params,
ControlInterface,
ExecutionInterface,
OutputToInputMapType outputToInputMap,
Add Mask capabilities to worklets Mask objects allow you to specify which output values should be generated when a worklet is run. That is, the Mask allows you to skip the invocation of a worklet for any number of outputs.
2019-01-21 02:14:55 +00:00
VisitArrayType visitArray,
ThreadToOutputMapType threadToOutputMap)
Add Scatter parameters to Invocation. We are passing in execution objects with the Invocation when the Worklet is scheduled, but we are not using it yet.
2015-09-22 04:35:13 +00:00
{
Respect VTK-m convention of parameters all or nothing on a line clang-format BinPack settings have been disabled to make sure that the VTK-m style guideline is obeyed.
2017-05-26 17:53:28 +00:00
return vtkm::internal::Invocation<ParameterInterface,
ControlInterface,
ExecutionInterface,
InputDomainIndex,
OutputToInputMapType,
Add Mask capabilities to worklets Mask objects allow you to specify which output values should be generated when a worklet is run. That is, the Mask allows you to skip the invocation of a worklet for any number of outputs.
2019-01-21 02:14:55 +00:00
VisitArrayType,
ThreadToOutputMapType>(
params, outputToInputMap, visitArray, threadToOutputMap);
Add Scatter parameters to Invocation. We are passing in execution objects with the Invocation when the Worklet is scheduled, but we are not using it yet.
2015-09-22 04:35:13 +00:00
}
Respect VTK-m convention of parameters all or nothing on a line clang-format BinPack settings have been disabled to make sure that the VTK-m style guideline is obeyed.
2017-05-26 17:53:28 +00:00
template <vtkm::IdComponent InputDomainIndex,
typename ControlInterface,
typename ExecutionInterface,
typename ParameterInterface>
VTKM_CONT vtkm::internal::
Invocation<ParameterInterface, ControlInterface, ExecutionInterface, InputDomainIndex>
make_Invocation(const ParameterInterface& params,
ControlInterface = ControlInterface(),
ExecutionInterface = ExecutionInterface())
Add Fetch class The Fetch class is responsible for moving data in and out of some collection in the execution environment. The Fetch class is templated with a pair of tags (the type of fetch and the aspect) that control the mechanism used for the fetch.
2014-10-15 19:52:27 +00:00
{
Respect VTK-m convention of parameters all or nothing on a line clang-format BinPack settings have been disabled to make sure that the VTK-m style guideline is obeyed.
2017-05-26 17:53:28 +00:00
return vtkm::internal::make_Invocation<InputDomainIndex>(params,
ControlInterface(),
ExecutionInterface(),
vtkm::internal::NullType(),
Add Mask capabilities to worklets Mask objects allow you to specify which output values should be generated when a worklet is run. That is, the Mask allows you to skip the invocation of a worklet for any number of outputs.
2019-01-21 02:14:55 +00:00
vtkm::internal::NullType(),
Respect VTK-m convention of parameters all or nothing on a line clang-format BinPack settings have been disabled to make sure that the VTK-m style guideline is obeyed.
2017-05-26 17:53:28 +00:00
vtkm::internal::NullType());
Add Fetch class The Fetch class is responsible for moving data in and out of some collection in the execution environment. The Fetch class is templated with a pair of tags (the type of fetch and the aspect) that control the mechanism used for the fetch.
2014-10-15 19:52:27 +00:00
}
}
} // namespace vtkm::internal
#endif //vtk_m_internal_Invocation_h
Reference in New Issue Copy Permalink