Shuenhoy/vtk-m
1
0
Fork 0
mirror of https://gitlab.kitware.com/vtk/vtk-m synced 2024-09-20 19:15:45 +00:00
Code Issues 2 Actions Packages Projects Releases Wiki Activity
696ca48bd1
vtk-m/vtkm/worklet/internal/DispatcherBase.h

554 lines
20 KiB
C
Raw Normal View History

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
//============================================================================
// Copyright (c) Kitware, Inc.
// All rights reserved.
// See LICENSE.txt for details.
// This software is distributed WITHOUT ANY WARRANTY; without even
// the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
// PURPOSE. See the above copyright notice for more information.
//
// Copyright 2014 Sandia Corporation.
// Copyright 2014 UT-Battelle, LLC.
The Copyright statement now has all the periods in the correct location.
2015-05-21 12:09:22 +00:00
// Copyright 2014 Los Alamos National Security.
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
//
// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
// the U.S. Government retains certain rights in this software.
//
// Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National
// Laboratory (LANL), the U.S. Government retains certain rights in
// this software.
//============================================================================
#ifndef vtk_m_worklet_internal_DispatcherBase_h
#define vtk_m_worklet_internal_DispatcherBase_h
Declare new VTKM_STATIC_ASSERT This is to be used in place of BOOST_STATIC_ASSERT so that we can control its implementation. The implementation is designed to fix the issue where the latest XCode clang compiler gives a warning about a unused typedefs when the boost static assert is used within a function. (This warning also happens when using the C++11 static_assert keyword.) You can suppress this warning with _Pragma commands, but _Pragma commands inside a block is not supported in GCC. The implementation of VTKM_STATIC_ASSERT handles all current cases.
2015-09-17 19:45:35 +00:00
#include <vtkm/StaticAssert.h>
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
#include <vtkm/internal/FunctionInterface.h>
#include <vtkm/internal/Invocation.h>
#include <vtkm/cont/DeviceAdapter.h>
Add basic support for type checking of Invoke arguments
2014-10-22 21:15:14 +00:00
#include <vtkm/cont/ErrorControlBadType.h>
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 checks for signature tags It's easy to put accidently put something that is not a valid tag in a ControlSignature or ExecutionSignature. Previously, when you did that you got a weird error at the end of a very long template instantiation chain that made it difficult to find the offending worklet. This adds some type checks when the dispatcher is instantated to check the signatures. It doesn't point directly to the signature or its parameter, but it is much closer.
2014-10-23 14:28:50 +00:00
#include <vtkm/cont/arg/ControlSignatureTagBase.h>
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
#include <vtkm/cont/arg/Transport.h>
Add basic support for type checking of Invoke arguments
2014-10-22 21:15:14 +00:00
#include <vtkm/cont/arg/TypeCheck.h>
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
#include <vtkm/cont/internal/DynamicTransform.h>
Add checks for signature tags It's easy to put accidently put something that is not a valid tag in a ControlSignature or ExecutionSignature. Previously, when you did that you got a weird error at the end of a very long template instantiation chain that made it difficult to find the offending worklet. This adds some type checks when the dispatcher is instantated to check the signatures. It doesn't point directly to the signature or its parameter, but it is much closer.
2014-10-23 14:28:50 +00:00
#include <vtkm/exec/arg/ExecutionSignatureTagBase.h>
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
#include <vtkm/exec/internal/WorkletInvokeFunctor.h>
Rename pragma header guard so it makes sense for tbb and thrust. Boost is not the only thirdparty that we are supressing warnings for, so make the name more generic.
2015-08-12 19:08:45 +00:00
VTKM_THIRDPARTY_PRE_INCLUDE
Improve the error message for Invoke type mismatch at compile time. Now that we can skip generating the DynamicTransform code when all the arguments are statically known, we need a way to produce nicer error messages.
2015-10-26 20:35:02 +00:00
#include <boost/mpl/at.hpp>
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
#include <boost/mpl/assert.hpp>
Only perform DynamicTransformCont if at least one parameter is dynamic. Previously we always ran DynamicTransformCont even if we knew all the types. By checking for Dynamic types first, we save roughly 3% on the binary size. This also is a good starting point for a redesign of DynamicTransformCont
2015-10-23 20:27:49 +00:00
#include <boost/mpl/fold.hpp>
Improve the error message for Invoke type mismatch at compile time. Now that we can skip generating the DynamicTransform code when all the arguments are statically known, we need a way to produce nicer error messages.
2015-10-26 20:35:02 +00:00
#include <boost/mpl/find.hpp>
#include <boost/mpl/zip_view.hpp>
#include <boost/mpl/vector.hpp>
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
#include <boost/type_traits/is_base_of.hpp>
Add basic support for type checking of Invoke arguments
2014-10-22 21:15:14 +00:00
#include <boost/utility/enable_if.hpp>
Rename pragma header guard so it makes sense for tbb and thrust. Boost is not the only thirdparty that we are supressing warnings for, so make the name more generic.
2015-08-12 19:08:45 +00:00
VTKM_THIRDPARTY_POST_INCLUDE
Add basic support for type checking of Invoke arguments
2014-10-22 21:15:14 +00:00
#include <sstream>
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
namespace vtkm {
namespace worklet {
namespace internal {
namespace detail {
Remove the usage of enable_if from method signatures to reduce binary size. Using enable_if/disable_if as a return type has a negative impact on binary size compared to use a boost::true/false_type as a method parameter. For comparison the WorkletTests_TBB sees a 6-7% reduction in binary size when compiled with O3. Origin WorkletTests_TBB size details: __TEXT __DATA __OBJC others dec hex 2363392 49152 0 4297793536 4300206080 1004ff000 Updated WorkletTests_TBB size details: __TEXT __DATA __OBJC others dec hex 2215936 49152 0 4297568256 4299833344 1004a4000
2015-07-17 12:49:43 +00:00
// This code is actually taking an error found at compile-time and not
// reporting it until run-time. This seems strange at first, but this
// behavior is actually important. With dynamic arrays and similar dynamic
// classes, there may be types that are technically possible (such as using a
// vector where a scalar is expected) but in reality never happen. Thus, for
// these unsupported combinations we just silently halt the compiler from
// attempting to create code for these errant conditions and throw a run-time
// error if one every tries to create one.
inline void PrintFailureMessage(int, boost::true_type) {}
inline void PrintFailureMessage(int index, boost::false_type)
{
std::stringstream message;
message << "Encountered bad type for parameter "
<< index
<< " when calling Invoke on a dispatcher.";
throw vtkm::cont::ErrorControlBadType(message.str());
}
Improve the error message for Invoke type mismatch at compile time. Now that we can skip generating the DynamicTransform code when all the arguments are statically known, we need a way to produce nicer error messages.
2015-10-26 20:35:02 +00:00
// Is designed as a boost mpl binary metafunction.
Only perform DynamicTransformCont if at least one parameter is dynamic. Previously we always ran DynamicTransformCont even if we knew all the types. By checking for Dynamic types first, we save roughly 3% on the binary size. This also is a good starting point for a redesign of DynamicTransformCont
2015-10-23 20:27:49 +00:00
struct DetermineIfHasDynamicParameter
{
template<typename T, typename U>
struct apply
{
typedef typename vtkm::cont::internal::DynamicTransformTraits<U>::DynamicTag DynamicTag;
typedef typename boost::is_same<
DynamicTag,
vtkm::cont::internal::DynamicTransformTagCastAndCall>::type UType;
typedef typename boost::mpl::or_<T,UType>::type type;
};
};
Improve the error message for Invoke type mismatch at compile time. Now that we can skip generating the DynamicTransform code when all the arguments are statically known, we need a way to produce nicer error messages.
2015-10-26 20:35:02 +00:00
template<typename ValueType, typename TagList>
void NiceInCorrectParameterErrorMessage()
{
VTKM_STATIC_ASSERT_MSG(ValueType() == TagList(),
"Unable to match 'ValueType' to the signature tag 'ControlSignatureTag'" );
}
template<typename T>
void ShowInCorrectParameter(boost::mpl::true_, T) {}
template<typename T>
void ShowInCorrectParameter(boost::mpl::false_, T)
{
typedef typename boost::mpl::deref<T>::type ZipType;
typedef typename boost::mpl::at_c<ZipType,0>::type ValueType;
typedef typename boost::mpl::at_c<ZipType,1>::type ControlSignatureTag;
NiceInCorrectParameterErrorMessage<ValueType,ControlSignatureTag>();
};
// Is designed as a boost mpl unary metafunction.
struct DetermineHasInCorrectParameters
{
//When we find parameters that don't match, we set our 'type' to true_
//otherwise we are false_
template<typename T>
struct apply
{
typedef typename boost::mpl::at_c<T,0>::type ValueType;
typedef typename boost::mpl::at_c<T,1>::type ControlSignatureTag;
typedef typename ControlSignatureTag::TypeCheckTag TypeCheckTag;
typedef boost::mpl::bool_<
vtkm::cont::arg::TypeCheck<TypeCheckTag,ValueType>::value> CanContinueTagType;
//We need to not the result of CanContinueTagType, because we want to return
//true when we have the first parameter that DOES NOT match the control
//signature requirements
typedef typename boost::mpl::not_< typename CanContinueTagType::type
>::type type;
};
};
Add checks for signature tags It's easy to put accidently put something that is not a valid tag in a ControlSignature or ExecutionSignature. Previously, when you did that you got a weird error at the end of a very long template instantiation chain that made it difficult to find the offending worklet. This adds some type checks when the dispatcher is instantated to check the signatures. It doesn't point directly to the signature or its parameter, but it is much closer.
2014-10-23 14:28:50 +00:00
// Checks that an argument in a ControlSignature is a valid control signature
// tag. Causes a compile error otherwise.
struct DispatcherBaseControlSignatureTagCheck
{
Add index tags to FunctionInterface features. The functors in the ForEach, StaticTransform, and DynamicTransform methods sometimes can use the index of the parameter that they are operating on. This can be a helpful diagnostic in compile and run-time errors. It is also helpful when linking parameters from one FunctionInterface with those of another. This new features are now replacing implementations using the Zip functionality that was removed earlier. The implementation is actually simplified a bit.
2015-01-14 01:26:13 +00:00
template<typename ControlSignatureTag, vtkm::IdComponent Index>
Add checks for signature tags It's easy to put accidently put something that is not a valid tag in a ControlSignature or ExecutionSignature. Previously, when you did that you got a weird error at the end of a very long template instantiation chain that made it difficult to find the offending worklet. This adds some type checks when the dispatcher is instantated to check the signatures. It doesn't point directly to the signature or its parameter, but it is much closer.
2014-10-23 14:28:50 +00:00
struct ReturnType {
// If you get a compile error here, it means there is something that is
// not a valid control signature tag in a worklet's ControlSignature.
VTKM_IS_CONTROL_SIGNATURE_TAG(ControlSignatureTag);
typedef ControlSignatureTag type;
};
};
// Checks that an argument in a ExecutionSignature is a valid execution
// signature tag. Causes a compile error otherwise.
struct DispatcherBaseExecutionSignatureTagCheck
{
Add index tags to FunctionInterface features. The functors in the ForEach, StaticTransform, and DynamicTransform methods sometimes can use the index of the parameter that they are operating on. This can be a helpful diagnostic in compile and run-time errors. It is also helpful when linking parameters from one FunctionInterface with those of another. This new features are now replacing implementations using the Zip functionality that was removed earlier. The implementation is actually simplified a bit.
2015-01-14 01:26:13 +00:00
template<typename ExecutionSignatureTag, vtkm::IdComponent Index>
Add checks for signature tags It's easy to put accidently put something that is not a valid tag in a ControlSignature or ExecutionSignature. Previously, when you did that you got a weird error at the end of a very long template instantiation chain that made it difficult to find the offending worklet. This adds some type checks when the dispatcher is instantated to check the signatures. It doesn't point directly to the signature or its parameter, but it is much closer.
2014-10-23 14:28:50 +00:00
struct ReturnType {
// If you get a compile error here, it means there is something that is not
// a valid execution signature tag in a worklet's ExecutionSignature.
VTKM_IS_EXECUTION_SIGNATURE_TAG(ExecutionSignatureTag);
typedef ExecutionSignatureTag type;
};
};
// Used in the dynamic cast to check to make sure that the type passed into
// the Invoke method matches the type accepted by the ControlSignature.
Add index tags to FunctionInterface features. The functors in the ForEach, StaticTransform, and DynamicTransform methods sometimes can use the index of the parameter that they are operating on. This can be a helpful diagnostic in compile and run-time errors. It is also helpful when linking parameters from one FunctionInterface with those of another. This new features are now replacing implementations using the Zip functionality that was removed earlier. The implementation is actually simplified a bit.
2015-01-14 01:26:13 +00:00
template<typename ContinueFunctor,
typename TypeCheckTag,
vtkm::IdComponent Index>
Add basic support for type checking of Invoke arguments
2014-10-22 21:15:14 +00:00
struct DispatcherBaseTypeCheckFunctor
{
const ContinueFunctor &Continue;
VTKM_CONT_EXPORT
Add index tags to FunctionInterface features. The functors in the ForEach, StaticTransform, and DynamicTransform methods sometimes can use the index of the parameter that they are operating on. This can be a helpful diagnostic in compile and run-time errors. It is also helpful when linking parameters from one FunctionInterface with those of another. This new features are now replacing implementations using the Zip functionality that was removed earlier. The implementation is actually simplified a bit.
2015-01-14 01:26:13 +00:00
DispatcherBaseTypeCheckFunctor(const ContinueFunctor &continueFunc)
: Continue(continueFunc) { }
Add basic support for type checking of Invoke arguments
2014-10-22 21:15:14 +00:00
template<typename T>
VTKM_CONT_EXPORT
Remove the usage of enable_if from method signatures to reduce binary size. Using enable_if/disable_if as a return type has a negative impact on binary size compared to use a boost::true/false_type as a method parameter. For comparison the WorkletTests_TBB sees a 6-7% reduction in binary size when compiled with O3. Origin WorkletTests_TBB size details: __TEXT __DATA __OBJC others dec hex 2363392 49152 0 4297793536 4300206080 1004ff000 Updated WorkletTests_TBB size details: __TEXT __DATA __OBJC others dec hex 2215936 49152 0 4297568256 4299833344 1004a4000
2015-07-17 12:49:43 +00:00
void operator()(const T &x) const
Add basic support for type checking of Invoke arguments
2014-10-22 21:15:14 +00:00
{
Remove the usage of enable_if from method signatures to reduce binary size. Using enable_if/disable_if as a return type has a negative impact on binary size compared to use a boost::true/false_type as a method parameter. For comparison the WorkletTests_TBB sees a 6-7% reduction in binary size when compiled with O3. Origin WorkletTests_TBB size details: __TEXT __DATA __OBJC others dec hex 2363392 49152 0 4297793536 4300206080 1004ff000 Updated WorkletTests_TBB size details: __TEXT __DATA __OBJC others dec hex 2215936 49152 0 4297568256 4299833344 1004a4000
2015-07-17 12:49:43 +00:00
typedef boost::integral_constant<bool,
vtkm::cont::arg::TypeCheck<TypeCheckTag,T>::value> CanContinueTagType;
vtkm::worklet::internal::detail::PrintFailureMessage(Index,CanContinueTagType());
this->WillContinue(x, CanContinueTagType());
Add basic support for type checking of Invoke arguments
2014-10-22 21:15:14 +00:00
}
Remove the usage of enable_if from method signatures to reduce binary size. Using enable_if/disable_if as a return type has a negative impact on binary size compared to use a boost::true/false_type as a method parameter. For comparison the WorkletTests_TBB sees a 6-7% reduction in binary size when compiled with O3. Origin WorkletTests_TBB size details: __TEXT __DATA __OBJC others dec hex 2363392 49152 0 4297793536 4300206080 1004ff000 Updated WorkletTests_TBB size details: __TEXT __DATA __OBJC others dec hex 2215936 49152 0 4297568256 4299833344 1004a4000
2015-07-17 12:49:43 +00:00
private:
Add basic support for type checking of Invoke arguments
2014-10-22 21:15:14 +00:00
template<typename T>
VTKM_CONT_EXPORT
Remove the usage of enable_if from method signatures to reduce binary size. Using enable_if/disable_if as a return type has a negative impact on binary size compared to use a boost::true/false_type as a method parameter. For comparison the WorkletTests_TBB sees a 6-7% reduction in binary size when compiled with O3. Origin WorkletTests_TBB size details: __TEXT __DATA __OBJC others dec hex 2363392 49152 0 4297793536 4300206080 1004ff000 Updated WorkletTests_TBB size details: __TEXT __DATA __OBJC others dec hex 2215936 49152 0 4297568256 4299833344 1004a4000
2015-07-17 12:49:43 +00:00
void WillContinue(const T &x, boost::true_type) const
Add basic support for type checking of Invoke arguments
2014-10-22 21:15:14 +00:00
{
Remove the usage of enable_if from method signatures to reduce binary size. Using enable_if/disable_if as a return type has a negative impact on binary size compared to use a boost::true/false_type as a method parameter. For comparison the WorkletTests_TBB sees a 6-7% reduction in binary size when compiled with O3. Origin WorkletTests_TBB size details: __TEXT __DATA __OBJC others dec hex 2363392 49152 0 4297793536 4300206080 1004ff000 Updated WorkletTests_TBB size details: __TEXT __DATA __OBJC others dec hex 2215936 49152 0 4297568256 4299833344 1004a4000
2015-07-17 12:49:43 +00:00
this->Continue(x);
Add basic support for type checking of Invoke arguments
2014-10-22 21:15:14 +00:00
}
Remove the usage of enable_if from method signatures to reduce binary size. Using enable_if/disable_if as a return type has a negative impact on binary size compared to use a boost::true/false_type as a method parameter. For comparison the WorkletTests_TBB sees a 6-7% reduction in binary size when compiled with O3. Origin WorkletTests_TBB size details: __TEXT __DATA __OBJC others dec hex 2363392 49152 0 4297793536 4300206080 1004ff000 Updated WorkletTests_TBB size details: __TEXT __DATA __OBJC others dec hex 2215936 49152 0 4297568256 4299833344 1004a4000
2015-07-17 12:49:43 +00:00
template<typename T>
VTKM_CONT_EXPORT
void WillContinue(const T&, boost::false_type) const
{ }
Add basic support for type checking of Invoke arguments
2014-10-22 21:15:14 +00:00
};
Add checks for signature tags It's easy to put accidently put something that is not a valid tag in a ControlSignature or ExecutionSignature. Previously, when you did that you got a weird error at the end of a very long template instantiation chain that made it difficult to find the offending worklet. This adds some type checks when the dispatcher is instantated to check the signatures. It doesn't point directly to the signature or its parameter, but it is much closer.
2014-10-23 14:28:50 +00:00
// Uses vtkm::cont::internal::DynamicTransform and the DynamicTransformCont
// method of FunctionInterface to convert all DynamicArrayHandles and any
// other arguments declaring themselves as dynamic to static versions.
Add index tags to FunctionInterface features. The functors in the ForEach, StaticTransform, and DynamicTransform methods sometimes can use the index of the parameter that they are operating on. This can be a helpful diagnostic in compile and run-time errors. It is also helpful when linking parameters from one FunctionInterface with those of another. This new features are now replacing implementations using the Zip functionality that was removed earlier. The implementation is actually simplified a bit.
2015-01-14 01:26:13 +00:00
template<typename ControlInterface>
Add basic support for type checking of Invoke arguments
2014-10-22 21:15:14 +00:00
struct DispatcherBaseDynamicTransform
{
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
vtkm::cont::internal::DynamicTransform BasicDynamicTransform;
Add index tags to FunctionInterface features. The functors in the ForEach, StaticTransform, and DynamicTransform methods sometimes can use the index of the parameter that they are operating on. This can be a helpful diagnostic in compile and run-time errors. It is also helpful when linking parameters from one FunctionInterface with those of another. This new features are now replacing implementations using the Zip functionality that was removed earlier. The implementation is actually simplified a bit.
2015-01-14 01:26:13 +00:00
template<typename InputType,
typename ContinueFunctor,
vtkm::IdComponent Index>
Add basic support for type checking of Invoke arguments
2014-10-22 21:15:14 +00:00
VTKM_CONT_EXPORT
Add index tags to FunctionInterface features. The functors in the ForEach, StaticTransform, and DynamicTransform methods sometimes can use the index of the parameter that they are operating on. This can be a helpful diagnostic in compile and run-time errors. It is also helpful when linking parameters from one FunctionInterface with those of another. This new features are now replacing implementations using the Zip functionality that was removed earlier. The implementation is actually simplified a bit.
2015-01-14 01:26:13 +00:00
void operator()(const InputType &input,
const ContinueFunctor &continueFunc,
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 vtkm::internal::IndexTag<Index>& indexTag) const
Add basic support for type checking of Invoke arguments
2014-10-22 21:15:14 +00:00
{
Add index tags to FunctionInterface features. The functors in the ForEach, StaticTransform, and DynamicTransform methods sometimes can use the index of the parameter that they are operating on. This can be a helpful diagnostic in compile and run-time errors. It is also helpful when linking parameters from one FunctionInterface with those of another. This new features are now replacing implementations using the Zip functionality that was removed earlier. The implementation is actually simplified a bit.
2015-01-14 01:26:13 +00:00
typedef typename ControlInterface::template ParameterType<Index>::type
ControlSignatureTag;
Add basic support for type checking of Invoke arguments
2014-10-22 21:15:14 +00:00
typedef DispatcherBaseTypeCheckFunctor<
Add index tags to FunctionInterface features. The functors in the ForEach, StaticTransform, and DynamicTransform methods sometimes can use the index of the parameter that they are operating on. This can be a helpful diagnostic in compile and run-time errors. It is also helpful when linking parameters from one FunctionInterface with those of another. This new features are now replacing implementations using the Zip functionality that was removed earlier. The implementation is actually simplified a bit.
2015-01-14 01:26:13 +00:00
ContinueFunctor, typename ControlSignatureTag::TypeCheckTag, Index>
Add basic support for type checking of Invoke arguments
2014-10-22 21:15:14 +00:00
TypeCheckFunctor;
Add index tags to FunctionInterface features. The functors in the ForEach, StaticTransform, and DynamicTransform methods sometimes can use the index of the parameter that they are operating on. This can be a helpful diagnostic in compile and run-time errors. It is also helpful when linking parameters from one FunctionInterface with those of another. This new features are now replacing implementations using the Zip functionality that was removed earlier. The implementation is actually simplified a bit.
2015-01-14 01:26:13 +00:00
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
this->BasicDynamicTransform(input, TypeCheckFunctor(continueFunc), indexTag);
Add basic support for type checking of Invoke arguments
2014-10-22 21:15:14 +00:00
}
};
Add checks for signature tags It's easy to put accidently put something that is not a valid tag in a ControlSignature or ExecutionSignature. Previously, when you did that you got a weird error at the end of a very long template instantiation chain that made it difficult to find the offending worklet. This adds some type checks when the dispatcher is instantated to check the signatures. It doesn't point directly to the signature or its parameter, but it is much closer.
2014-10-23 14:28:50 +00:00
// A functor called at the end of the dynamic transform to call the next
// step in the dynamic transform.
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
template<typename DispatcherBaseType>
struct DispatcherBaseDynamicTransformHelper
{
const DispatcherBaseType *Dispatcher;
VTKM_CONT_EXPORT
DispatcherBaseDynamicTransformHelper(const DispatcherBaseType *dispatcher)
: Dispatcher(dispatcher) { }
template<typename FunctionInterface>
VTKM_CONT_EXPORT
void operator()(const FunctionInterface &parameters) const {
Improve the error message for Invoke type mismatch at compile time. Now that we can skip generating the DynamicTransform code when all the arguments are statically known, we need a way to produce nicer error messages.
2015-10-26 20:35:02 +00:00
this->Dispatcher->DynamicTransformInvoke(parameters, boost::mpl::true_() );
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
}
};
Remove unnecessary template parameters from DispatcherMapField DispatcherMapField was templated on the device adapter but it actually doesn't need to be, only BasicInvoke and subsequent methods need to be templated on the device.
2015-10-21 21:20:27 +00:00
// A look up helper used by DispatcherBaseTransportFunctor to determine
//the types independent of the device we are templated on.
template<typename ControlInterface, vtkm::IdComponent Index>
struct DispatcherBaseTransportInvokeTypes
{
//Moved out of DispatcherBaseTransportFunctor to reduce code generation
typedef typename ControlInterface::template ParameterType<Index>::type
ControlSignatureTag;
typedef typename ControlSignatureTag::TransportTag TransportTag;
};
Add checks for signature tags It's easy to put accidently put something that is not a valid tag in a ControlSignature or ExecutionSignature. Previously, when you did that you got a weird error at the end of a very long template instantiation chain that made it difficult to find the offending worklet. This adds some type checks when the dispatcher is instantated to check the signatures. It doesn't point directly to the signature or its parameter, but it is much closer.
2014-10-23 14:28:50 +00:00
// A functor used in a StaticCast of a FunctionInterface to transport arguments
// from the control environment to the execution environment.
Add index tags to FunctionInterface features. The functors in the ForEach, StaticTransform, and DynamicTransform methods sometimes can use the index of the parameter that they are operating on. This can be a helpful diagnostic in compile and run-time errors. It is also helpful when linking parameters from one FunctionInterface with those of another. This new features are now replacing implementations using the Zip functionality that was removed earlier. The implementation is actually simplified a bit.
2015-01-14 01:26:13 +00:00
template<typename ControlInterface, typename Device>
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
struct DispatcherBaseTransportFunctor
{
vtkm::Id NumInstances;
Improve 3D scheduling mechanism in DispatcherBase Previously, DispatcherBase had an ivar to determine whether to use the numInstances passed on the stack or to use a 3D range held in a different ivar. This change allows either a 1D range or 3D range to be passed on the stack, which I expect to be closer to how we we handle this when 3D ranges are fully supported. This also fixes a bug introduced with commit fdac208acbfa47b613d899a36cefc32a01e8f0a8 where the Use3DSchedule ivar was not set correctly in UnitTestDispatcherBase.
2015-05-05 14:46:23 +00:00
VTKM_CONT_EXPORT
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
DispatcherBaseTransportFunctor(vtkm::Id numInstances)
: NumInstances(numInstances) { }
Improve 3D scheduling mechanism in DispatcherBase Previously, DispatcherBase had an ivar to determine whether to use the numInstances passed on the stack or to use a 3D range held in a different ivar. This change allows either a 1D range or 3D range to be passed on the stack, which I expect to be closer to how we we handle this when 3D ranges are fully supported. This also fixes a bug introduced with commit fdac208acbfa47b613d899a36cefc32a01e8f0a8 where the Use3DSchedule ivar was not set correctly in UnitTestDispatcherBase.
2015-05-05 14:46:23 +00:00
// 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
// 3D indices (for example, allocate a 3D array instead of a 1D array).
// But for now, just treat all transports as 1D arrays.
VTKM_CONT_EXPORT
DispatcherBaseTransportFunctor(vtkm::Id3 dimensions)
: NumInstances(dimensions[0]*dimensions[1]*dimensions[2]) { }
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 index tags to FunctionInterface features. The functors in the ForEach, StaticTransform, and DynamicTransform methods sometimes can use the index of the parameter that they are operating on. This can be a helpful diagnostic in compile and run-time errors. It is also helpful when linking parameters from one FunctionInterface with those of another. This new features are now replacing implementations using the Zip functionality that was removed earlier. The implementation is actually simplified a bit.
2015-01-14 01:26:13 +00:00
template<typename ControlParameter, vtkm::IdComponent Index>
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
struct ReturnType {
Remove unnecessary template parameters from DispatcherMapField DispatcherMapField was templated on the device adapter but it actually doesn't need to be, only BasicInvoke and subsequent methods need to be templated on the device.
2015-10-21 21:20:27 +00:00
typedef typename DispatcherBaseTransportInvokeTypes<ControlInterface, Index>::TransportTag TransportTag;
typedef typename vtkm::cont::arg::Transport<TransportTag,ControlParameter,Device> TransportType;
typedef typename TransportType::ExecObjectType type;
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 index tags to FunctionInterface features. The functors in the ForEach, StaticTransform, and DynamicTransform methods sometimes can use the index of the parameter that they are operating on. This can be a helpful diagnostic in compile and run-time errors. It is also helpful when linking parameters from one FunctionInterface with those of another. This new features are now replacing implementations using the Zip functionality that was removed earlier. The implementation is actually simplified a bit.
2015-01-14 01:26:13 +00:00
template<typename ControlParameter, vtkm::IdComponent Index>
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
VTKM_CONT_EXPORT
Add index tags to FunctionInterface features. The functors in the ForEach, StaticTransform, and DynamicTransform methods sometimes can use the index of the parameter that they are operating on. This can be a helpful diagnostic in compile and run-time errors. It is also helpful when linking parameters from one FunctionInterface with those of another. This new features are now replacing implementations using the Zip functionality that was removed earlier. The implementation is actually simplified a bit.
2015-01-14 01:26:13 +00:00
typename ReturnType<ControlParameter, Index>::type
operator()(const ControlParameter &invokeData,
Remove unnecessary template parameters from DispatcherMapField DispatcherMapField was templated on the device adapter but it actually doesn't need to be, only BasicInvoke and subsequent methods need to be templated on the device.
2015-10-21 21:20:27 +00:00
vtkm::internal::IndexTag<Index>) const
{
typedef typename DispatcherBaseTransportInvokeTypes<ControlInterface, Index>::TransportTag TransportTag;
vtkm::cont::arg::Transport<TransportTag,ControlParameter,Device> transport;
Add index tags to FunctionInterface features. The functors in the ForEach, StaticTransform, and DynamicTransform methods sometimes can use the index of the parameter that they are operating on. This can be a helpful diagnostic in compile and run-time errors. It is also helpful when linking parameters from one FunctionInterface with those of another. This new features are now replacing implementations using the Zip functionality that was removed earlier. The implementation is actually simplified a bit.
2015-01-14 01:26:13 +00:00
return transport(invokeData, this->NumInstances);
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
}
};
} // namespace detail
/// Base class for all dispatcher classes. Every worklet type should have its
/// own dispatcher.
///
template<typename DerivedClass,
typename WorkletType,
Remove unnecessary template parameters from DispatcherMapField DispatcherMapField was templated on the device adapter but it actually doesn't need to be, only BasicInvoke and subsequent methods need to be templated on the device.
2015-10-21 21:20:27 +00:00
typename BaseWorkletType>
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
class DispatcherBase
{
private:
Remove unnecessary template parameters from DispatcherMapField DispatcherMapField was templated on the device adapter but it actually doesn't need to be, only BasicInvoke and subsequent methods need to be templated on the device.
2015-10-21 21:20:27 +00:00
typedef DispatcherBase<DerivedClass,WorkletType,BaseWorkletType> MyType;
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
friend struct detail::DispatcherBaseDynamicTransformHelper<MyType>;
protected:
typedef vtkm::internal::FunctionInterface<
typename WorkletType::ControlSignature> ControlInterface;
typedef vtkm::internal::FunctionInterface<
typename WorkletType::ExecutionSignature> ExecutionInterface;
static const vtkm::IdComponent NUM_INVOKE_PARAMS = ControlInterface::ARITY;
Add checks for signature tags It's easy to put accidently put something that is not a valid tag in a ControlSignature or ExecutionSignature. Previously, when you did that you got a weird error at the end of a very long template instantiation chain that made it difficult to find the offending worklet. This adds some type checks when the dispatcher is instantated to check the signatures. It doesn't point directly to the signature or its parameter, but it is much closer.
2014-10-23 14:28:50 +00:00
private:
// We don't really need these types, but declaring them checks the arguments
// of the control and execution signatures.
typedef typename ControlInterface::
template StaticTransformType<
detail::DispatcherBaseControlSignatureTagCheck>::type
ControlSignatureCheck;
typedef typename ExecutionInterface::
template StaticTransformType<
detail::DispatcherBaseExecutionSignatureTagCheck>::type
ExecutionSignatureCheck;
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
template<typename Signature>
VTKM_CONT_EXPORT
void StartInvoke(
const vtkm::internal::FunctionInterface<Signature> &parameters) const
{
typedef vtkm::internal::FunctionInterface<Signature> ParameterInterface;
Declare new VTKM_STATIC_ASSERT This is to be used in place of BOOST_STATIC_ASSERT so that we can control its implementation. The implementation is designed to fix the issue where the latest XCode clang compiler gives a warning about a unused typedefs when the boost static assert is used within a function. (This warning also happens when using the C++11 static_assert keyword.) You can suppress this warning with _Pragma commands, but _Pragma commands inside a block is not supported in GCC. The implementation of VTKM_STATIC_ASSERT handles all current cases.
2015-09-17 19:45:35 +00:00
VTKM_STATIC_ASSERT_MSG(ParameterInterface::ARITY == NUM_INVOKE_PARAMS,
"Dispatcher Invoke called with wrong number of arguments.");
Add third party wrappers around boost macros. The boost assert macros seem to have an issue where they define an unused typedef. This is causing the XCode 7 compiler to issue a warning. Since the offending code is in a macro, the warning is identified with the VTK-m header even though the code is in boost. To get around this, wrap all uses of the boost assert that is causing the warning in the third party pre/post macros to disable the warning.
2015-09-17 05:34:49 +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
BOOST_MPL_ASSERT(( boost::is_base_of<BaseWorkletType,WorkletType> ));
Only perform DynamicTransformCont if at least one parameter is dynamic. Previously we always ran DynamicTransformCont even if we knew all the types. By checking for Dynamic types first, we save roughly 3% on the binary size. This also is a good starting point for a redesign of DynamicTransformCont
2015-10-23 20:27:49 +00:00
//We need to determine if we have the need to do any dynamic
//transforms. This is fairly simple of a query. We just need to check
//everything in the FunctionInterface and see if any of them have the
//proper dynamic trait. Doing this, allows us to generate zero dynamic
//check & convert code when we already know all the types. This results
//in smaller executables and libraries.
typedef boost::function_types::parameter_types<Signature> MPLSignatureForm;
typedef typename boost::mpl::fold<
MPLSignatureForm,
Improve the error message for Invoke type mismatch at compile time. Now that we can skip generating the DynamicTransform code when all the arguments are statically known, we need a way to produce nicer error messages.
2015-10-26 20:35:02 +00:00
boost::mpl::false_,
Only perform DynamicTransformCont if at least one parameter is dynamic. Previously we always ran DynamicTransformCont even if we knew all the types. By checking for Dynamic types first, we save roughly 3% on the binary size. This also is a good starting point for a redesign of DynamicTransformCont
2015-10-23 20:27:49 +00:00
detail::DetermineIfHasDynamicParameter>::type HasDynamicTypes;
Improve the error message for Invoke type mismatch at compile time. Now that we can skip generating the DynamicTransform code when all the arguments are statically known, we need a way to produce nicer error messages.
2015-10-26 20:35:02 +00:00
Only perform DynamicTransformCont if at least one parameter is dynamic. Previously we always ran DynamicTransformCont even if we knew all the types. By checking for Dynamic types first, we save roughly 3% on the binary size. This also is a good starting point for a redesign of DynamicTransformCont
2015-10-23 20:27:49 +00:00
this->StartInvokeDynamic(parameters, HasDynamicTypes() );
}
template<typename Signature>
VTKM_CONT_EXPORT
void StartInvokeDynamic(
const vtkm::internal::FunctionInterface<Signature> &parameters,
Improve the error message for Invoke type mismatch at compile time. Now that we can skip generating the DynamicTransform code when all the arguments are statically known, we need a way to produce nicer error messages.
2015-10-26 20:35:02 +00:00
boost::mpl::true_) const
Only perform DynamicTransformCont if at least one parameter is dynamic. Previously we always ran DynamicTransformCont even if we knew all the types. By checking for Dynamic types first, we save roughly 3% on the binary size. This also is a good starting point for a redesign of DynamicTransformCont
2015-10-23 20:27:49 +00:00
{
Add basic support for type checking of Invoke arguments
2014-10-22 21:15:14 +00:00
// As we do the dynamic transform, we are also going to check the static
// type against the TypeCheckTag in the ControlSignature tags. To do this,
// the check needs access to both the parameter (in the parameters
// argument) and the ControlSignature tags (in the ControlInterface type).
Add index tags to FunctionInterface features. The functors in the ForEach, StaticTransform, and DynamicTransform methods sometimes can use the index of the parameter that they are operating on. This can be a helpful diagnostic in compile and run-time errors. It is also helpful when linking parameters from one FunctionInterface with those of another. This new features are now replacing implementations using the Zip functionality that was removed earlier. The implementation is actually simplified a bit.
2015-01-14 01:26:13 +00:00
// To make this possible, we call DynamicTransform with a functor containing
// the control signature tags. It uses the index provided by the
// dynamic transform mechanism to get the right tag and make sure that
// the dynamic type is correct. (This prevents the compiler from expanding
// worklets with types that should not be.)
parameters.DynamicTransformCont(
detail::DispatcherBaseDynamicTransform<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
detail::DispatcherBaseDynamicTransformHelper<MyType>(this));
}
Only perform DynamicTransformCont if at least one parameter is dynamic. Previously we always ran DynamicTransformCont even if we knew all the types. By checking for Dynamic types first, we save roughly 3% on the binary size. This also is a good starting point for a redesign of DynamicTransformCont
2015-10-23 20:27:49 +00:00
template<typename Signature>
VTKM_CONT_EXPORT
void StartInvokeDynamic(
const vtkm::internal::FunctionInterface<Signature> &parameters,
Improve the error message for Invoke type mismatch at compile time. Now that we can skip generating the DynamicTransform code when all the arguments are statically known, we need a way to produce nicer error messages.
2015-10-26 20:35:02 +00:00
boost::mpl::false_) const
Only perform DynamicTransformCont if at least one parameter is dynamic. Previously we always ran DynamicTransformCont even if we knew all the types. By checking for Dynamic types first, we save roughly 3% on the binary size. This also is a good starting point for a redesign of DynamicTransformCont
2015-10-23 20:27:49 +00:00
{
//Nothing requires a conversion from dynamic to static types, so
Improve the error message for Invoke type mismatch at compile time. Now that we can skip generating the DynamicTransform code when all the arguments are statically known, we need a way to produce nicer error messages.
2015-10-26 20:35:02 +00:00
//next we need to verify that each argument's type is correct. If not
//we need to throw a nice compile time error
typedef boost::function_types::parameter_types<Signature> MPLSignatureForm;
typedef typename boost::function_types::parameter_types<
typename WorkletType::ControlSignature > WorkletContSignature;
typedef boost::mpl::vector< MPLSignatureForm, WorkletContSignature > ZippedSignatures;
typedef boost::mpl::zip_view<ZippedSignatures> ZippedView;
typedef typename boost::mpl::find_if<
ZippedView,
detail::DetermineHasInCorrectParameters>::type LocationOfIncorrectParameter;
typedef typename boost::is_same< LocationOfIncorrectParameter,
typename boost::mpl::end< ZippedView>::type >::type HasOnlyCorrectTypes;
//When HasOnlyCorrectTypes is false we produce an error
//message which should state what the parameter type and tag type is
//that failed to match.
detail::ShowInCorrectParameter(HasOnlyCorrectTypes(),
LocationOfIncorrectParameter());
this->DynamicTransformInvoke(parameters, HasOnlyCorrectTypes());
Only perform DynamicTransformCont if at least one parameter is dynamic. Previously we always ran DynamicTransformCont even if we knew all the types. By checking for Dynamic types first, we save roughly 3% on the binary size. This also is a good starting point for a redesign of DynamicTransformCont
2015-10-23 20:27:49 +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
template<typename Signature>
VTKM_CONT_EXPORT
void DynamicTransformInvoke(
Improve the error message for Invoke type mismatch at compile time. Now that we can skip generating the DynamicTransform code when all the arguments are statically known, we need a way to produce nicer error messages.
2015-10-26 20:35:02 +00:00
const vtkm::internal::FunctionInterface<Signature> &parameters,
boost::mpl::true_ ) 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
{
// TODO: Check parameters
static const vtkm::IdComponent INPUT_DOMAIN_INDEX =
WorkletType::InputDomain::INDEX;
reinterpret_cast<const DerivedClass *>(this)->DoInvoke(
vtkm::internal::make_Invocation<INPUT_DOMAIN_INDEX>(
parameters, ControlInterface(), ExecutionInterface()));
}
Improve the error message for Invoke type mismatch at compile time. Now that we can skip generating the DynamicTransform code when all the arguments are statically known, we need a way to produce nicer error messages.
2015-10-26 20:35:02 +00:00
template<typename Signature>
VTKM_CONT_EXPORT
void DynamicTransformInvoke(
const vtkm::internal::FunctionInterface<Signature> &,
boost::mpl::false_ ) 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
public:
// Implementation of the Invoke method is in this generated file.
#include <vtkm/worklet/internal/DispatcherBaseDetailInvoke.h>
protected:
VTKM_CONT_EXPORT
DispatcherBase(const WorkletType &worklet) : Worklet(worklet) { }
Remove unnecessary template parameters from DispatcherMapField DispatcherMapField was templated on the device adapter but it actually doesn't need to be, only BasicInvoke and subsequent methods need to be templated on the device.
2015-10-21 21:20:27 +00:00
template<typename Invocation, typename DeviceAdapter>
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
VTKM_CONT_EXPORT
Remove unnecessary template parameters from DispatcherMapField DispatcherMapField was templated on the device adapter but it actually doesn't need to be, only BasicInvoke and subsequent methods need to be templated on the device.
2015-10-21 21:20:27 +00:00
void BasicInvoke(const Invocation &invocation,
vtkm::Id numInstances,
Adding ScatterCounting
2015-09-24 22:38:42 +00:00
DeviceAdapter device) 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
{
Adding ScatterCounting
2015-09-24 22:38:42 +00:00
this->InvokeTransportParameters(
invocation,
Allocate the scatter arrays to be proper length. The previous code would over allocate all the scatter arrays since it was computing the output range, than using that as the input range.
2016-03-15 17:13:34 +00:00
numInstances,
Adding ScatterCounting
2015-09-24 22:38:42 +00:00
this->Worklet.GetScatter().GetOutputRange(numInstances),
device);
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
}
Remove unnecessary template parameters from DispatcherMapField DispatcherMapField was templated on the device adapter but it actually doesn't need to be, only BasicInvoke and subsequent methods need to be templated on the device.
2015-10-21 21:20:27 +00:00
template<typename Invocation, typename DeviceAdapter>
Allow dispatching based on a vtkm::Id2. This is being added so that it is easy to schedule 2d grids easily, without them having to pass in a 3d range.
2015-06-22 13:07:27 +00:00
VTKM_CONT_EXPORT
Remove unnecessary template parameters from DispatcherMapField DispatcherMapField was templated on the device adapter but it actually doesn't need to be, only BasicInvoke and subsequent methods need to be templated on the device.
2015-10-21 21:20:27 +00:00
void BasicInvoke(const Invocation &invocation,
vtkm::Id2 dimensions,
Adding ScatterCounting
2015-09-24 22:38:42 +00:00
DeviceAdapter device) const
Allow dispatching based on a vtkm::Id2. This is being added so that it is easy to schedule 2d grids easily, without them having to pass in a 3d range.
2015-06-22 13:07:27 +00:00
{
Adding ScatterCounting
2015-09-24 22:38:42 +00:00
this->BasicInvoke(invocation,
vtkm::Id3(dimensions[0], dimensions[1], 1),
device);
Allow dispatching based on a vtkm::Id2. This is being added so that it is easy to schedule 2d grids easily, without them having to pass in a 3d range.
2015-06-22 13:07:27 +00:00
}
Remove unnecessary template parameters from DispatcherMapField DispatcherMapField was templated on the device adapter but it actually doesn't need to be, only BasicInvoke and subsequent methods need to be templated on the device.
2015-10-21 21:20:27 +00:00
template<typename Invocation, typename DeviceAdapter>
Improve 3D scheduling mechanism in DispatcherBase Previously, DispatcherBase had an ivar to determine whether to use the numInstances passed on the stack or to use a 3D range held in a different ivar. This change allows either a 1D range or 3D range to be passed on the stack, which I expect to be closer to how we we handle this when 3D ranges are fully supported. This also fixes a bug introduced with commit fdac208acbfa47b613d899a36cefc32a01e8f0a8 where the Use3DSchedule ivar was not set correctly in UnitTestDispatcherBase.
2015-05-05 14:46:23 +00:00
VTKM_CONT_EXPORT
Remove unnecessary template parameters from DispatcherMapField DispatcherMapField was templated on the device adapter but it actually doesn't need to be, only BasicInvoke and subsequent methods need to be templated on the device.
2015-10-21 21:20:27 +00:00
void BasicInvoke(const Invocation &invocation,
vtkm::Id3 dimensions,
Adding ScatterCounting
2015-09-24 22:38:42 +00:00
DeviceAdapter device) const
Improve 3D scheduling mechanism in DispatcherBase Previously, DispatcherBase had an ivar to determine whether to use the numInstances passed on the stack or to use a 3D range held in a different ivar. This change allows either a 1D range or 3D range to be passed on the stack, which I expect to be closer to how we we handle this when 3D ranges are fully supported. This also fixes a bug introduced with commit fdac208acbfa47b613d899a36cefc32a01e8f0a8 where the Use3DSchedule ivar was not set correctly in UnitTestDispatcherBase.
2015-05-05 14:46:23 +00:00
{
Adding ScatterCounting
2015-09-24 22:38:42 +00:00
this->InvokeTransportParameters(
invocation,
Allocate the scatter arrays to be proper length. The previous code would over allocate all the scatter arrays since it was computing the output range, than using that as the input range.
2016-03-15 17:13:34 +00:00
dimensions,
Adding ScatterCounting
2015-09-24 22:38:42 +00:00
this->Worklet.GetScatter().GetOutputRange(dimensions),
device);
Improve 3D scheduling mechanism in DispatcherBase Previously, DispatcherBase had an ivar to determine whether to use the numInstances passed on the stack or to use a 3D range held in a different ivar. This change allows either a 1D range or 3D range to be passed on the stack, which I expect to be closer to how we we handle this when 3D ranges are fully supported. This also fixes a bug introduced with commit fdac208acbfa47b613d899a36cefc32a01e8f0a8 where the Use3DSchedule ivar was not set correctly in UnitTestDispatcherBase.
2015-05-05 14:46:23 +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
WorkletType Worklet;
private:
// These are not implemented. Dispatchers cannot be copied.
DispatcherBase(const MyType &);
void operator=(const MyType &);
Allocate the scatter arrays to be proper length. The previous code would over allocate all the scatter arrays since it was computing the output range, than using that as the input range.
2016-03-15 17:13:34 +00:00
template<typename Invocation, typename InputRangeType, typename OutputRangeType, typename DeviceAdapter>
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
VTKM_CONT_EXPORT
void InvokeTransportParameters(const Invocation &invocation,
Allocate the scatter arrays to be proper length. The previous code would over allocate all the scatter arrays since it was computing the output range, than using that as the input range.
2016-03-15 17:13:34 +00:00
const InputRangeType& inputRange,
const OutputRangeType& outputRange,
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
DeviceAdapter device) 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
{
Add index tags to FunctionInterface features. The functors in the ForEach, StaticTransform, and DynamicTransform methods sometimes can use the index of the parameter that they are operating on. This can be a helpful diagnostic in compile and run-time errors. It is also helpful when linking parameters from one FunctionInterface with those of another. This new features are now replacing implementations using the Zip functionality that was removed earlier. The implementation is actually simplified a bit.
2015-01-14 01:26:13 +00:00
// The first step in invoking a worklet is to transport the arguments to
// the execution environment. The invocation object passed to this function
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
// contains the parameters passed to Invoke in the control environment. We
// will use the template magic in the FunctionInterface class to invoke the
Add index tags to FunctionInterface features. The functors in the ForEach, StaticTransform, and DynamicTransform methods sometimes can use the index of the parameter that they are operating on. This can be a helpful diagnostic in compile and run-time errors. It is also helpful when linking parameters from one FunctionInterface with those of another. This new features are now replacing implementations using the Zip functionality that was removed earlier. The implementation is actually simplified a bit.
2015-01-14 01:26:13 +00:00
// appropriate Transport class on each parameter and get a list of
// execution objects (corresponding to the arguments of the Invoke in the
// control environment) in a FunctionInterface. Specifically, we use a
// static transform of the FunctionInterface to call the transport on each
// argument and return the corresponding execution environment object.
typedef typename Invocation::ParameterInterface ParameterInterfaceType;
const ParameterInterfaceType &parameters = invocation.Parameters;
typedef detail::DispatcherBaseTransportFunctor<
Remove unnecessary template parameters from DispatcherMapField DispatcherMapField was templated on the device adapter but it actually doesn't need to be, only BasicInvoke and subsequent methods need to be templated on the device.
2015-10-21 21:20:27 +00:00
typename Invocation::ControlInterface, DeviceAdapter> TransportFunctorType;
Add index tags to FunctionInterface features. The functors in the ForEach, StaticTransform, and DynamicTransform methods sometimes can use the index of the parameter that they are operating on. This can be a helpful diagnostic in compile and run-time errors. It is also helpful when linking parameters from one FunctionInterface with those of another. This new features are now replacing implementations using the Zip functionality that was removed earlier. The implementation is actually simplified a bit.
2015-01-14 01:26:13 +00:00
typedef typename ParameterInterfaceType::template StaticTransformType<
TransportFunctorType>::type ExecObjectParameters;
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
ExecObjectParameters execObjectParameters =
Allocate the scatter arrays to be proper length. The previous code would over allocate all the scatter arrays since it was computing the output range, than using that as the input range.
2016-03-15 17:13:34 +00:00
parameters.StaticTransformCont(TransportFunctorType(outputRange));
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 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
// Get the arrays used for scattering input to output.
typename WorkletType::ScatterType::OutputToInputMapType outputToInputMap =
Allocate the scatter arrays to be proper length. The previous code would over allocate all the scatter arrays since it was computing the output range, than using that as the input range.
2016-03-15 17:13:34 +00:00
this->Worklet.GetScatter().GetOutputToInputMap(inputRange);
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
typename WorkletType::ScatterType::VisitArrayType visitArray =
Allocate the scatter arrays to be proper length. The previous code would over allocate all the scatter arrays since it was computing the output range, than using that as the input range.
2016-03-15 17:13:34 +00:00
this->Worklet.GetScatter().GetVisitArray(inputRange);
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 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
// Replace the parameters in the invocation with the execution object and
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
// pass to next step of Invoke. Also add the scatter information.
this->InvokeSchedule(
invocation
.ChangeParameters(execObjectParameters)
.ChangeOutputToInputMap(outputToInputMap.PrepareForInput(device))
.ChangeVisitArray(visitArray.PrepareForInput(device)),
Allocate the scatter arrays to be proper length. The previous code would over allocate all the scatter arrays since it was computing the output range, than using that as the input range.
2016-03-15 17:13:34 +00:00
outputRange,
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
device);
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
}
Remove unnecessary template parameters from DispatcherMapField DispatcherMapField was templated on the device adapter but it actually doesn't need to be, only BasicInvoke and subsequent methods need to be templated on the device.
2015-10-21 21:20:27 +00:00
template<typename Invocation, typename RangeType, typename DeviceAdapter>
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
VTKM_CONT_EXPORT
Remove unnecessary template parameters from DispatcherMapField DispatcherMapField was templated on the device adapter but it actually doesn't need to be, only BasicInvoke and subsequent methods need to be templated on the device.
2015-10-21 21:20:27 +00:00
void InvokeSchedule(const Invocation &invocation,
RangeType range,
DeviceAdapter) 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
{
// The WorkletInvokeFunctor class handles the magic of fetching values
// for each instance and calling the worklet's function. So just create
// a WorkletInvokeFunctor and schedule it with the device adapter.
typedef vtkm::exec::internal::WorkletInvokeFunctor<WorkletType,Invocation>
WorkletInvokeFunctorType;
WorkletInvokeFunctorType workletFunctor =
WorkletInvokeFunctorType(this->Worklet, invocation);
Remove unnecessary template parameters from DispatcherMapField DispatcherMapField was templated on the device adapter but it actually doesn't need to be, only BasicInvoke and subsequent methods need to be templated on the device.
2015-10-21 21:20:27 +00:00
typedef vtkm::cont::DeviceAdapterAlgorithm<DeviceAdapter> Algorithm;
use cuda scheduling versus thrust scheduling.
2015-03-20 18:41:54 +00:00
Improve 3D scheduling mechanism in DispatcherBase Previously, DispatcherBase had an ivar to determine whether to use the numInstances passed on the stack or to use a 3D range held in a different ivar. This change allows either a 1D range or 3D range to be passed on the stack, which I expect to be closer to how we we handle this when 3D ranges are fully supported. This also fixes a bug introduced with commit fdac208acbfa47b613d899a36cefc32a01e8f0a8 where the Use3DSchedule ivar was not set correctly in UnitTestDispatcherBase.
2015-05-05 14:46:23 +00:00
Algorithm::Schedule(workletFunctor, range);
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
}
};
}
}
} // namespace vtkm::worklet::internal
#endif //vtk_m_worklet_internal_DispatcherBase_h
Reference in New Issue Copy Permalink