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
5f72eb9252
vtk-m/vtkm/internal/FunctionInterfaceDetailPre.h

3937 lines
119 KiB
C
Raw Normal View History

Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +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.
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +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.
//============================================================================
// **** DO NOT EDIT THIS FILE!!! ****
// This file is automatically generated by FunctionInterfaceDetailPre.h.in
Fix wrapper macros around FunctionInterface header files The header wrapper macros in all the FunctionInterface header files declared the function interface to be in the cont package, which is wrong.
2014-10-08 16:07:08 +00:00
#ifndef vtk_m_internal_FunctionInterfaceDetailPre_h
#define vtk_m_internal_FunctionInterfaceDetailPre_h
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
Fix wrapper macros around FunctionInterface header files The header wrapper macros in all the FunctionInterface header files declared the function interface to be in the cont package, which is wrong.
2014-10-08 16:07:08 +00:00
#if !defined(vtk_m_internal_FunctionInterface_h) && !defined(VTKM_TEST_HEADER_BUILD)
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
#error FunctionInterfaceDetailPre.h must be included from FunctionInterface.h
#endif
#include <vtkm/Types.h>
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
#include <vtkm/internal/IndexTag.h>
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
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
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
#include <boost/function_types/function_type.hpp>
#include <boost/mpl/at.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
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
#define VTKM_MAX_FUNCTION_PARAMETERS 10
namespace vtkm {
namespace internal {
/// This struct is used internally by FunctionInterface to store the return
/// value of a function. There is a special implementation for a return type of
/// void, which stores nothing.
///
template<typename T>
struct FunctionInterfaceReturnContainer {
T Value;
static const bool VALID = true;
};
template<>
struct FunctionInterfaceReturnContainer<void> {
// Nothing to store for void return.
static const bool VALID = false;
};
namespace detail {
//============================================================================
// This templated class contains the state of parameters. If you get a compiler
// error stating that this class is not specialized, that probably means that
// you are using FunctionInterface with an unsupported number of arguments.
template<typename FunctionSignature>
struct ParameterContainer;
template<typename R>
struct ParameterContainer<R()> {
};
template<typename R,
typename P1>
struct ParameterContainer<R(P1)> {
P1 Parameter1;
};
template<typename R,
typename P1,
typename P2>
struct ParameterContainer<R(P1,P2)> {
P1 Parameter1;
P2 Parameter2;
};
template<typename R,
typename P1,
typename P2,
typename P3>
struct ParameterContainer<R(P1,P2,P3)> {
P1 Parameter1;
P2 Parameter2;
P3 Parameter3;
};
template<typename R,
typename P1,
typename P2,
typename P3,
typename P4>
struct ParameterContainer<R(P1,P2,P3,P4)> {
P1 Parameter1;
P2 Parameter2;
P3 Parameter3;
P4 Parameter4;
};
template<typename R,
typename P1,
typename P2,
typename P3,
typename P4,
typename P5>
struct ParameterContainer<R(P1,P2,P3,P4,P5)> {
P1 Parameter1;
P2 Parameter2;
P3 Parameter3;
P4 Parameter4;
P5 Parameter5;
};
template<typename R,
typename P1,
typename P2,
typename P3,
typename P4,
typename P5,
typename P6>
struct ParameterContainer<R(P1,P2,P3,P4,P5,P6)> {
P1 Parameter1;
P2 Parameter2;
P3 Parameter3;
P4 Parameter4;
P5 Parameter5;
P6 Parameter6;
};
template<typename R,
typename P1,
typename P2,
typename P3,
typename P4,
typename P5,
typename P6,
typename P7>
struct ParameterContainer<R(P1,P2,P3,P4,P5,P6,P7)> {
P1 Parameter1;
P2 Parameter2;
P3 Parameter3;
P4 Parameter4;
P5 Parameter5;
P6 Parameter6;
P7 Parameter7;
};
template<typename R,
typename P1,
typename P2,
typename P3,
typename P4,
typename P5,
typename P6,
typename P7,
typename P8>
struct ParameterContainer<R(P1,P2,P3,P4,P5,P6,P7,P8)> {
P1 Parameter1;
P2 Parameter2;
P3 Parameter3;
P4 Parameter4;
P5 Parameter5;
P6 Parameter6;
P7 Parameter7;
P8 Parameter8;
};
template<typename R,
typename P1,
typename P2,
typename P3,
typename P4,
typename P5,
typename P6,
typename P7,
typename P8,
typename P9>
struct ParameterContainer<R(P1,P2,P3,P4,P5,P6,P7,P8,P9)> {
P1 Parameter1;
P2 Parameter2;
P3 Parameter3;
P4 Parameter4;
P5 Parameter5;
P6 Parameter6;
P7 Parameter7;
P8 Parameter8;
P9 Parameter9;
};
template<typename R,
typename P1,
typename P2,
typename P3,
typename P4,
typename P5,
typename P6,
typename P7,
typename P8,
typename P9,
typename P10>
struct ParameterContainer<R(P1,P2,P3,P4,P5,P6,P7,P8,P9,P10)> {
P1 Parameter1;
P2 Parameter2;
P3 Parameter3;
P4 Parameter4;
P5 Parameter5;
P6 Parameter6;
P7 Parameter7;
P8 Parameter8;
P9 Parameter9;
P10 Parameter10;
};
//============================================================================
template<int ParameterIndex, typename FunctionSignature>
struct ParameterContainerAccess;
template<typename FunctionSignature>
struct ParameterContainerAccess<1, FunctionSignature> {
typedef typename boost::mpl::at_c<
boost::function_types::components<FunctionSignature>, 1>::type
ParameterType;
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
VTKM_EXEC_CONT_EXPORT
static
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 ParameterType&
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
GetParameter(const ParameterContainer<FunctionSignature> &parameters) {
return parameters.Parameter1;
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
VTKM_EXEC_CONT_EXPORT
static
void SetParameter(ParameterContainer<FunctionSignature> &parameters,
const ParameterType &value) {
parameters.Parameter1 = value;
}
};
template<typename FunctionSignature>
struct ParameterContainerAccess<2, FunctionSignature> {
typedef typename boost::mpl::at_c<
boost::function_types::components<FunctionSignature>, 2>::type
ParameterType;
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
VTKM_EXEC_CONT_EXPORT
static
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 ParameterType&
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
GetParameter(const ParameterContainer<FunctionSignature> &parameters) {
return parameters.Parameter2;
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
VTKM_EXEC_CONT_EXPORT
static
void SetParameter(ParameterContainer<FunctionSignature> &parameters,
const ParameterType &value) {
parameters.Parameter2 = value;
}
};
template<typename FunctionSignature>
struct ParameterContainerAccess<3, FunctionSignature> {
typedef typename boost::mpl::at_c<
boost::function_types::components<FunctionSignature>, 3>::type
ParameterType;
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
VTKM_EXEC_CONT_EXPORT
static
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 ParameterType&
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
GetParameter(const ParameterContainer<FunctionSignature> &parameters) {
return parameters.Parameter3;
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
VTKM_EXEC_CONT_EXPORT
static
void SetParameter(ParameterContainer<FunctionSignature> &parameters,
const ParameterType &value) {
parameters.Parameter3 = value;
}
};
template<typename FunctionSignature>
struct ParameterContainerAccess<4, FunctionSignature> {
typedef typename boost::mpl::at_c<
boost::function_types::components<FunctionSignature>, 4>::type
ParameterType;
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
VTKM_EXEC_CONT_EXPORT
static
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 ParameterType&
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
GetParameter(const ParameterContainer<FunctionSignature> &parameters) {
return parameters.Parameter4;
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
VTKM_EXEC_CONT_EXPORT
static
void SetParameter(ParameterContainer<FunctionSignature> &parameters,
const ParameterType &value) {
parameters.Parameter4 = value;
}
};
template<typename FunctionSignature>
struct ParameterContainerAccess<5, FunctionSignature> {
typedef typename boost::mpl::at_c<
boost::function_types::components<FunctionSignature>, 5>::type
ParameterType;
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
VTKM_EXEC_CONT_EXPORT
static
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 ParameterType&
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
GetParameter(const ParameterContainer<FunctionSignature> &parameters) {
return parameters.Parameter5;
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
VTKM_EXEC_CONT_EXPORT
static
void SetParameter(ParameterContainer<FunctionSignature> &parameters,
const ParameterType &value) {
parameters.Parameter5 = value;
}
};
template<typename FunctionSignature>
struct ParameterContainerAccess<6, FunctionSignature> {
typedef typename boost::mpl::at_c<
boost::function_types::components<FunctionSignature>, 6>::type
ParameterType;
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
VTKM_EXEC_CONT_EXPORT
static
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 ParameterType&
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
GetParameter(const ParameterContainer<FunctionSignature> &parameters) {
return parameters.Parameter6;
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
VTKM_EXEC_CONT_EXPORT
static
void SetParameter(ParameterContainer<FunctionSignature> &parameters,
const ParameterType &value) {
parameters.Parameter6 = value;
}
};
template<typename FunctionSignature>
struct ParameterContainerAccess<7, FunctionSignature> {
typedef typename boost::mpl::at_c<
boost::function_types::components<FunctionSignature>, 7>::type
ParameterType;
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
VTKM_EXEC_CONT_EXPORT
static
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 ParameterType&
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
GetParameter(const ParameterContainer<FunctionSignature> &parameters) {
return parameters.Parameter7;
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
VTKM_EXEC_CONT_EXPORT
static
void SetParameter(ParameterContainer<FunctionSignature> &parameters,
const ParameterType &value) {
parameters.Parameter7 = value;
}
};
template<typename FunctionSignature>
struct ParameterContainerAccess<8, FunctionSignature> {
typedef typename boost::mpl::at_c<
boost::function_types::components<FunctionSignature>, 8>::type
ParameterType;
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
VTKM_EXEC_CONT_EXPORT
static
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 ParameterType&
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
GetParameter(const ParameterContainer<FunctionSignature> &parameters) {
return parameters.Parameter8;
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
VTKM_EXEC_CONT_EXPORT
static
void SetParameter(ParameterContainer<FunctionSignature> &parameters,
const ParameterType &value) {
parameters.Parameter8 = value;
}
};
template<typename FunctionSignature>
struct ParameterContainerAccess<9, FunctionSignature> {
typedef typename boost::mpl::at_c<
boost::function_types::components<FunctionSignature>, 9>::type
ParameterType;
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
VTKM_EXEC_CONT_EXPORT
static
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 ParameterType&
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
GetParameter(const ParameterContainer<FunctionSignature> &parameters) {
return parameters.Parameter9;
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
VTKM_EXEC_CONT_EXPORT
static
void SetParameter(ParameterContainer<FunctionSignature> &parameters,
const ParameterType &value) {
parameters.Parameter9 = value;
}
};
template<typename FunctionSignature>
struct ParameterContainerAccess<10, FunctionSignature> {
typedef typename boost::mpl::at_c<
boost::function_types::components<FunctionSignature>, 10>::type
ParameterType;
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
VTKM_EXEC_CONT_EXPORT
static
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 ParameterType&
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
GetParameter(const ParameterContainer<FunctionSignature> &parameters) {
return parameters.Parameter10;
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
VTKM_EXEC_CONT_EXPORT
static
void SetParameter(ParameterContainer<FunctionSignature> &parameters,
const ParameterType &value) {
parameters.Parameter10 = value;
}
};
//============================================================================
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Functor,
typename TransformFunctor,
typename R>
VTKM_CONT_EXPORT
void DoInvokeCont(
const Functor &f,
ParameterContainer<R()> &parameters,
FunctionInterfaceReturnContainer<R> &result,
const TransformFunctor &transform)
{
(void) parameters;
result.Value = transform(f());
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Functor,
typename TransformFunctor
>
VTKM_CONT_EXPORT
void DoInvokeCont(
const Functor &f,
ParameterContainer<void()> &parameters,
FunctionInterfaceReturnContainer<void> &,
const TransformFunctor &transform)
{
(void) parameters;
(void) transform;
f();
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Functor,
typename TransformFunctor,
typename R>
VTKM_CONT_EXPORT
void DoInvokeCont(
Functor &f,
ParameterContainer<R()> &parameters,
FunctionInterfaceReturnContainer<R> &result,
const TransformFunctor &transform)
{
(void) parameters;
result.Value = transform(f());
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Functor,
typename TransformFunctor
>
VTKM_CONT_EXPORT
void DoInvokeCont(
Functor &f,
ParameterContainer<void()> &parameters,
FunctionInterfaceReturnContainer<void> &,
const TransformFunctor &transform)
{
(void) parameters;
(void) transform;
f();
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Functor,
typename TransformFunctor,
typename R>
VTKM_EXEC_EXPORT
void DoInvokeExec(
const Functor &f,
ParameterContainer<R()> &parameters,
FunctionInterfaceReturnContainer<R> &result,
const TransformFunctor &transform)
{
(void) parameters;
result.Value = transform(f());
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Functor,
typename TransformFunctor
>
VTKM_EXEC_EXPORT
void DoInvokeExec(
const Functor &f,
ParameterContainer<void()> &parameters,
FunctionInterfaceReturnContainer<void> &,
const TransformFunctor &transform)
{
(void) parameters;
(void) transform;
f();
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Functor,
typename TransformFunctor,
typename R>
VTKM_EXEC_EXPORT
void DoInvokeExec(
Functor &f,
ParameterContainer<R()> &parameters,
FunctionInterfaceReturnContainer<R> &result,
const TransformFunctor &transform)
{
(void) parameters;
result.Value = transform(f());
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Functor,
typename TransformFunctor
>
VTKM_EXEC_EXPORT
void DoInvokeExec(
Functor &f,
ParameterContainer<void()> &parameters,
FunctionInterfaceReturnContainer<void> &,
const TransformFunctor &transform)
{
(void) parameters;
(void) transform;
f();
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Functor,
typename TransformFunctor,
typename R,
typename P1>
VTKM_CONT_EXPORT
void DoInvokeCont(
const Functor &f,
ParameterContainer<R(P1)> &parameters,
FunctionInterfaceReturnContainer<R> &result,
const TransformFunctor &transform)
{
result.Value = transform(f(
transform(parameters.Parameter1)));
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Functor,
typename TransformFunctor,
typename P1>
VTKM_CONT_EXPORT
void DoInvokeCont(
const Functor &f,
ParameterContainer<void(P1)> &parameters,
FunctionInterfaceReturnContainer<void> &,
const TransformFunctor &transform)
{
f(
transform(parameters.Parameter1));
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Functor,
typename TransformFunctor,
typename R,
typename P1>
VTKM_CONT_EXPORT
void DoInvokeCont(
Functor &f,
ParameterContainer<R(P1)> &parameters,
FunctionInterfaceReturnContainer<R> &result,
const TransformFunctor &transform)
{
result.Value = transform(f(
transform(parameters.Parameter1)));
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Functor,
typename TransformFunctor,
typename P1>
VTKM_CONT_EXPORT
void DoInvokeCont(
Functor &f,
ParameterContainer<void(P1)> &parameters,
FunctionInterfaceReturnContainer<void> &,
const TransformFunctor &transform)
{
f(
transform(parameters.Parameter1));
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Functor,
typename TransformFunctor,
typename R,
typename P1>
VTKM_EXEC_EXPORT
void DoInvokeExec(
const Functor &f,
ParameterContainer<R(P1)> &parameters,
FunctionInterfaceReturnContainer<R> &result,
const TransformFunctor &transform)
{
result.Value = transform(f(
transform(parameters.Parameter1)));
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Functor,
typename TransformFunctor,
typename P1>
VTKM_EXEC_EXPORT
void DoInvokeExec(
const Functor &f,
ParameterContainer<void(P1)> &parameters,
FunctionInterfaceReturnContainer<void> &,
const TransformFunctor &transform)
{
f(
transform(parameters.Parameter1));
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Functor,
typename TransformFunctor,
typename R,
typename P1>
VTKM_EXEC_EXPORT
void DoInvokeExec(
Functor &f,
ParameterContainer<R(P1)> &parameters,
FunctionInterfaceReturnContainer<R> &result,
const TransformFunctor &transform)
{
result.Value = transform(f(
transform(parameters.Parameter1)));
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Functor,
typename TransformFunctor,
typename P1>
VTKM_EXEC_EXPORT
void DoInvokeExec(
Functor &f,
ParameterContainer<void(P1)> &parameters,
FunctionInterfaceReturnContainer<void> &,
const TransformFunctor &transform)
{
f(
transform(parameters.Parameter1));
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Functor,
typename TransformFunctor,
typename R,
typename P1,
typename P2>
VTKM_CONT_EXPORT
void DoInvokeCont(
const Functor &f,
ParameterContainer<R(P1,P2)> &parameters,
FunctionInterfaceReturnContainer<R> &result,
const TransformFunctor &transform)
{
result.Value = transform(f(
transform(parameters.Parameter1),
transform(parameters.Parameter2)));
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Functor,
typename TransformFunctor,
typename P1,
typename P2>
VTKM_CONT_EXPORT
void DoInvokeCont(
const Functor &f,
ParameterContainer<void(P1,P2)> &parameters,
FunctionInterfaceReturnContainer<void> &,
const TransformFunctor &transform)
{
f(
transform(parameters.Parameter1),
transform(parameters.Parameter2));
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Functor,
typename TransformFunctor,
typename R,
typename P1,
typename P2>
VTKM_CONT_EXPORT
void DoInvokeCont(
Functor &f,
ParameterContainer<R(P1,P2)> &parameters,
FunctionInterfaceReturnContainer<R> &result,
const TransformFunctor &transform)
{
result.Value = transform(f(
transform(parameters.Parameter1),
transform(parameters.Parameter2)));
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Functor,
typename TransformFunctor,
typename P1,
typename P2>
VTKM_CONT_EXPORT
void DoInvokeCont(
Functor &f,
ParameterContainer<void(P1,P2)> &parameters,
FunctionInterfaceReturnContainer<void> &,
const TransformFunctor &transform)
{
f(
transform(parameters.Parameter1),
transform(parameters.Parameter2));
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Functor,
typename TransformFunctor,
typename R,
typename P1,
typename P2>
VTKM_EXEC_EXPORT
void DoInvokeExec(
const Functor &f,
ParameterContainer<R(P1,P2)> &parameters,
FunctionInterfaceReturnContainer<R> &result,
const TransformFunctor &transform)
{
result.Value = transform(f(
transform(parameters.Parameter1),
transform(parameters.Parameter2)));
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Functor,
typename TransformFunctor,
typename P1,
typename P2>
VTKM_EXEC_EXPORT
void DoInvokeExec(
const Functor &f,
ParameterContainer<void(P1,P2)> &parameters,
FunctionInterfaceReturnContainer<void> &,
const TransformFunctor &transform)
{
f(
transform(parameters.Parameter1),
transform(parameters.Parameter2));
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Functor,
typename TransformFunctor,
typename R,
typename P1,
typename P2>
VTKM_EXEC_EXPORT
void DoInvokeExec(
Functor &f,
ParameterContainer<R(P1,P2)> &parameters,
FunctionInterfaceReturnContainer<R> &result,
const TransformFunctor &transform)
{
result.Value = transform(f(
transform(parameters.Parameter1),
transform(parameters.Parameter2)));
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Functor,
typename TransformFunctor,
typename P1,
typename P2>
VTKM_EXEC_EXPORT
void DoInvokeExec(
Functor &f,
ParameterContainer<void(P1,P2)> &parameters,
FunctionInterfaceReturnContainer<void> &,
const TransformFunctor &transform)
{
f(
transform(parameters.Parameter1),
transform(parameters.Parameter2));
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Functor,
typename TransformFunctor,
typename R,
typename P1,
typename P2,
typename P3>
VTKM_CONT_EXPORT
void DoInvokeCont(
const Functor &f,
ParameterContainer<R(P1,P2,P3)> &parameters,
FunctionInterfaceReturnContainer<R> &result,
const TransformFunctor &transform)
{
result.Value = transform(f(
transform(parameters.Parameter1),
transform(parameters.Parameter2),
transform(parameters.Parameter3)));
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Functor,
typename TransformFunctor,
typename P1,
typename P2,
typename P3>
VTKM_CONT_EXPORT
void DoInvokeCont(
const Functor &f,
ParameterContainer<void(P1,P2,P3)> &parameters,
FunctionInterfaceReturnContainer<void> &,
const TransformFunctor &transform)
{
f(
transform(parameters.Parameter1),
transform(parameters.Parameter2),
transform(parameters.Parameter3));
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Functor,
typename TransformFunctor,
typename R,
typename P1,
typename P2,
typename P3>
VTKM_CONT_EXPORT
void DoInvokeCont(
Functor &f,
ParameterContainer<R(P1,P2,P3)> &parameters,
FunctionInterfaceReturnContainer<R> &result,
const TransformFunctor &transform)
{
result.Value = transform(f(
transform(parameters.Parameter1),
transform(parameters.Parameter2),
transform(parameters.Parameter3)));
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Functor,
typename TransformFunctor,
typename P1,
typename P2,
typename P3>
VTKM_CONT_EXPORT
void DoInvokeCont(
Functor &f,
ParameterContainer<void(P1,P2,P3)> &parameters,
FunctionInterfaceReturnContainer<void> &,
const TransformFunctor &transform)
{
f(
transform(parameters.Parameter1),
transform(parameters.Parameter2),
transform(parameters.Parameter3));
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Functor,
typename TransformFunctor,
typename R,
typename P1,
typename P2,
typename P3>
VTKM_EXEC_EXPORT
void DoInvokeExec(
const Functor &f,
ParameterContainer<R(P1,P2,P3)> &parameters,
FunctionInterfaceReturnContainer<R> &result,
const TransformFunctor &transform)
{
result.Value = transform(f(
transform(parameters.Parameter1),
transform(parameters.Parameter2),
transform(parameters.Parameter3)));
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Functor,
typename TransformFunctor,
typename P1,
typename P2,
typename P3>
VTKM_EXEC_EXPORT
void DoInvokeExec(
const Functor &f,
ParameterContainer<void(P1,P2,P3)> &parameters,
FunctionInterfaceReturnContainer<void> &,
const TransformFunctor &transform)
{
f(
transform(parameters.Parameter1),
transform(parameters.Parameter2),
transform(parameters.Parameter3));
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Functor,
typename TransformFunctor,
typename R,
typename P1,
typename P2,
typename P3>
VTKM_EXEC_EXPORT
void DoInvokeExec(
Functor &f,
ParameterContainer<R(P1,P2,P3)> &parameters,
FunctionInterfaceReturnContainer<R> &result,
const TransformFunctor &transform)
{
result.Value = transform(f(
transform(parameters.Parameter1),
transform(parameters.Parameter2),
transform(parameters.Parameter3)));
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Functor,
typename TransformFunctor,
typename P1,
typename P2,
typename P3>
VTKM_EXEC_EXPORT
void DoInvokeExec(
Functor &f,
ParameterContainer<void(P1,P2,P3)> &parameters,
FunctionInterfaceReturnContainer<void> &,
const TransformFunctor &transform)
{
f(
transform(parameters.Parameter1),
transform(parameters.Parameter2),
transform(parameters.Parameter3));
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Functor,
typename TransformFunctor,
typename R,
typename P1,
typename P2,
typename P3,
typename P4>
VTKM_CONT_EXPORT
void DoInvokeCont(
const Functor &f,
ParameterContainer<R(P1,P2,P3,P4)> &parameters,
FunctionInterfaceReturnContainer<R> &result,
const TransformFunctor &transform)
{
result.Value = transform(f(
transform(parameters.Parameter1),
transform(parameters.Parameter2),
transform(parameters.Parameter3),
transform(parameters.Parameter4)));
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Functor,
typename TransformFunctor,
typename P1,
typename P2,
typename P3,
typename P4>
VTKM_CONT_EXPORT
void DoInvokeCont(
const Functor &f,
ParameterContainer<void(P1,P2,P3,P4)> &parameters,
FunctionInterfaceReturnContainer<void> &,
const TransformFunctor &transform)
{
f(
transform(parameters.Parameter1),
transform(parameters.Parameter2),
transform(parameters.Parameter3),
transform(parameters.Parameter4));
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Functor,
typename TransformFunctor,
typename R,
typename P1,
typename P2,
typename P3,
typename P4>
VTKM_CONT_EXPORT
void DoInvokeCont(
Functor &f,
ParameterContainer<R(P1,P2,P3,P4)> &parameters,
FunctionInterfaceReturnContainer<R> &result,
const TransformFunctor &transform)
{
result.Value = transform(f(
transform(parameters.Parameter1),
transform(parameters.Parameter2),
transform(parameters.Parameter3),
transform(parameters.Parameter4)));
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Functor,
typename TransformFunctor,
typename P1,
typename P2,
typename P3,
typename P4>
VTKM_CONT_EXPORT
void DoInvokeCont(
Functor &f,
ParameterContainer<void(P1,P2,P3,P4)> &parameters,
FunctionInterfaceReturnContainer<void> &,
const TransformFunctor &transform)
{
f(
transform(parameters.Parameter1),
transform(parameters.Parameter2),
transform(parameters.Parameter3),
transform(parameters.Parameter4));
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Functor,
typename TransformFunctor,
typename R,
typename P1,
typename P2,
typename P3,
typename P4>
VTKM_EXEC_EXPORT
void DoInvokeExec(
const Functor &f,
ParameterContainer<R(P1,P2,P3,P4)> &parameters,
FunctionInterfaceReturnContainer<R> &result,
const TransformFunctor &transform)
{
result.Value = transform(f(
transform(parameters.Parameter1),
transform(parameters.Parameter2),
transform(parameters.Parameter3),
transform(parameters.Parameter4)));
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Functor,
typename TransformFunctor,
typename P1,
typename P2,
typename P3,
typename P4>
VTKM_EXEC_EXPORT
void DoInvokeExec(
const Functor &f,
ParameterContainer<void(P1,P2,P3,P4)> &parameters,
FunctionInterfaceReturnContainer<void> &,
const TransformFunctor &transform)
{
f(
transform(parameters.Parameter1),
transform(parameters.Parameter2),
transform(parameters.Parameter3),
transform(parameters.Parameter4));
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Functor,
typename TransformFunctor,
typename R,
typename P1,
typename P2,
typename P3,
typename P4>
VTKM_EXEC_EXPORT
void DoInvokeExec(
Functor &f,
ParameterContainer<R(P1,P2,P3,P4)> &parameters,
FunctionInterfaceReturnContainer<R> &result,
const TransformFunctor &transform)
{
result.Value = transform(f(
transform(parameters.Parameter1),
transform(parameters.Parameter2),
transform(parameters.Parameter3),
transform(parameters.Parameter4)));
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Functor,
typename TransformFunctor,
typename P1,
typename P2,
typename P3,
typename P4>
VTKM_EXEC_EXPORT
void DoInvokeExec(
Functor &f,
ParameterContainer<void(P1,P2,P3,P4)> &parameters,
FunctionInterfaceReturnContainer<void> &,
const TransformFunctor &transform)
{
f(
transform(parameters.Parameter1),
transform(parameters.Parameter2),
transform(parameters.Parameter3),
transform(parameters.Parameter4));
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Functor,
typename TransformFunctor,
typename R,
typename P1,
typename P2,
typename P3,
typename P4,
typename P5>
VTKM_CONT_EXPORT
void DoInvokeCont(
const Functor &f,
ParameterContainer<R(P1,P2,P3,P4,P5)> &parameters,
FunctionInterfaceReturnContainer<R> &result,
const TransformFunctor &transform)
{
result.Value = transform(f(
transform(parameters.Parameter1),
transform(parameters.Parameter2),
transform(parameters.Parameter3),
transform(parameters.Parameter4),
transform(parameters.Parameter5)));
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Functor,
typename TransformFunctor,
typename P1,
typename P2,
typename P3,
typename P4,
typename P5>
VTKM_CONT_EXPORT
void DoInvokeCont(
const Functor &f,
ParameterContainer<void(P1,P2,P3,P4,P5)> &parameters,
FunctionInterfaceReturnContainer<void> &,
const TransformFunctor &transform)
{
f(
transform(parameters.Parameter1),
transform(parameters.Parameter2),
transform(parameters.Parameter3),
transform(parameters.Parameter4),
transform(parameters.Parameter5));
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Functor,
typename TransformFunctor,
typename R,
typename P1,
typename P2,
typename P3,
typename P4,
typename P5>
VTKM_CONT_EXPORT
void DoInvokeCont(
Functor &f,
ParameterContainer<R(P1,P2,P3,P4,P5)> &parameters,
FunctionInterfaceReturnContainer<R> &result,
const TransformFunctor &transform)
{
result.Value = transform(f(
transform(parameters.Parameter1),
transform(parameters.Parameter2),
transform(parameters.Parameter3),
transform(parameters.Parameter4),
transform(parameters.Parameter5)));
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Functor,
typename TransformFunctor,
typename P1,
typename P2,
typename P3,
typename P4,
typename P5>
VTKM_CONT_EXPORT
void DoInvokeCont(
Functor &f,
ParameterContainer<void(P1,P2,P3,P4,P5)> &parameters,
FunctionInterfaceReturnContainer<void> &,
const TransformFunctor &transform)
{
f(
transform(parameters.Parameter1),
transform(parameters.Parameter2),
transform(parameters.Parameter3),
transform(parameters.Parameter4),
transform(parameters.Parameter5));
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Functor,
typename TransformFunctor,
typename R,
typename P1,
typename P2,
typename P3,
typename P4,
typename P5>
VTKM_EXEC_EXPORT
void DoInvokeExec(
const Functor &f,
ParameterContainer<R(P1,P2,P3,P4,P5)> &parameters,
FunctionInterfaceReturnContainer<R> &result,
const TransformFunctor &transform)
{
result.Value = transform(f(
transform(parameters.Parameter1),
transform(parameters.Parameter2),
transform(parameters.Parameter3),
transform(parameters.Parameter4),
transform(parameters.Parameter5)));
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Functor,
typename TransformFunctor,
typename P1,
typename P2,
typename P3,
typename P4,
typename P5>
VTKM_EXEC_EXPORT
void DoInvokeExec(
const Functor &f,
ParameterContainer<void(P1,P2,P3,P4,P5)> &parameters,
FunctionInterfaceReturnContainer<void> &,
const TransformFunctor &transform)
{
f(
transform(parameters.Parameter1),
transform(parameters.Parameter2),
transform(parameters.Parameter3),
transform(parameters.Parameter4),
transform(parameters.Parameter5));
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Functor,
typename TransformFunctor,
typename R,
typename P1,
typename P2,
typename P3,
typename P4,
typename P5>
VTKM_EXEC_EXPORT
void DoInvokeExec(
Functor &f,
ParameterContainer<R(P1,P2,P3,P4,P5)> &parameters,
FunctionInterfaceReturnContainer<R> &result,
const TransformFunctor &transform)
{
result.Value = transform(f(
transform(parameters.Parameter1),
transform(parameters.Parameter2),
transform(parameters.Parameter3),
transform(parameters.Parameter4),
transform(parameters.Parameter5)));
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Functor,
typename TransformFunctor,
typename P1,
typename P2,
typename P3,
typename P4,
typename P5>
VTKM_EXEC_EXPORT
void DoInvokeExec(
Functor &f,
ParameterContainer<void(P1,P2,P3,P4,P5)> &parameters,
FunctionInterfaceReturnContainer<void> &,
const TransformFunctor &transform)
{
f(
transform(parameters.Parameter1),
transform(parameters.Parameter2),
transform(parameters.Parameter3),
transform(parameters.Parameter4),
transform(parameters.Parameter5));
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Functor,
typename TransformFunctor,
typename R,
typename P1,
typename P2,
typename P3,
typename P4,
typename P5,
typename P6>
VTKM_CONT_EXPORT
void DoInvokeCont(
const Functor &f,
ParameterContainer<R(P1,P2,P3,P4,P5,P6)> &parameters,
FunctionInterfaceReturnContainer<R> &result,
const TransformFunctor &transform)
{
result.Value = transform(f(
transform(parameters.Parameter1),
transform(parameters.Parameter2),
transform(parameters.Parameter3),
transform(parameters.Parameter4),
transform(parameters.Parameter5),
transform(parameters.Parameter6)));
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Functor,
typename TransformFunctor,
typename P1,
typename P2,
typename P3,
typename P4,
typename P5,
typename P6>
VTKM_CONT_EXPORT
void DoInvokeCont(
const Functor &f,
ParameterContainer<void(P1,P2,P3,P4,P5,P6)> &parameters,
FunctionInterfaceReturnContainer<void> &,
const TransformFunctor &transform)
{
f(
transform(parameters.Parameter1),
transform(parameters.Parameter2),
transform(parameters.Parameter3),
transform(parameters.Parameter4),
transform(parameters.Parameter5),
transform(parameters.Parameter6));
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Functor,
typename TransformFunctor,
typename R,
typename P1,
typename P2,
typename P3,
typename P4,
typename P5,
typename P6>
VTKM_CONT_EXPORT
void DoInvokeCont(
Functor &f,
ParameterContainer<R(P1,P2,P3,P4,P5,P6)> &parameters,
FunctionInterfaceReturnContainer<R> &result,
const TransformFunctor &transform)
{
result.Value = transform(f(
transform(parameters.Parameter1),
transform(parameters.Parameter2),
transform(parameters.Parameter3),
transform(parameters.Parameter4),
transform(parameters.Parameter5),
transform(parameters.Parameter6)));
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Functor,
typename TransformFunctor,
typename P1,
typename P2,
typename P3,
typename P4,
typename P5,
typename P6>
VTKM_CONT_EXPORT
void DoInvokeCont(
Functor &f,
ParameterContainer<void(P1,P2,P3,P4,P5,P6)> &parameters,
FunctionInterfaceReturnContainer<void> &,
const TransformFunctor &transform)
{
f(
transform(parameters.Parameter1),
transform(parameters.Parameter2),
transform(parameters.Parameter3),
transform(parameters.Parameter4),
transform(parameters.Parameter5),
transform(parameters.Parameter6));
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Functor,
typename TransformFunctor,
typename R,
typename P1,
typename P2,
typename P3,
typename P4,
typename P5,
typename P6>
VTKM_EXEC_EXPORT
void DoInvokeExec(
const Functor &f,
ParameterContainer<R(P1,P2,P3,P4,P5,P6)> &parameters,
FunctionInterfaceReturnContainer<R> &result,
const TransformFunctor &transform)
{
result.Value = transform(f(
transform(parameters.Parameter1),
transform(parameters.Parameter2),
transform(parameters.Parameter3),
transform(parameters.Parameter4),
transform(parameters.Parameter5),
transform(parameters.Parameter6)));
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Functor,
typename TransformFunctor,
typename P1,
typename P2,
typename P3,
typename P4,
typename P5,
typename P6>
VTKM_EXEC_EXPORT
void DoInvokeExec(
const Functor &f,
ParameterContainer<void(P1,P2,P3,P4,P5,P6)> &parameters,
FunctionInterfaceReturnContainer<void> &,
const TransformFunctor &transform)
{
f(
transform(parameters.Parameter1),
transform(parameters.Parameter2),
transform(parameters.Parameter3),
transform(parameters.Parameter4),
transform(parameters.Parameter5),
transform(parameters.Parameter6));
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Functor,
typename TransformFunctor,
typename R,
typename P1,
typename P2,
typename P3,
typename P4,
typename P5,
typename P6>
VTKM_EXEC_EXPORT
void DoInvokeExec(
Functor &f,
ParameterContainer<R(P1,P2,P3,P4,P5,P6)> &parameters,
FunctionInterfaceReturnContainer<R> &result,
const TransformFunctor &transform)
{
result.Value = transform(f(
transform(parameters.Parameter1),
transform(parameters.Parameter2),
transform(parameters.Parameter3),
transform(parameters.Parameter4),
transform(parameters.Parameter5),
transform(parameters.Parameter6)));
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Functor,
typename TransformFunctor,
typename P1,
typename P2,
typename P3,
typename P4,
typename P5,
typename P6>
VTKM_EXEC_EXPORT
void DoInvokeExec(
Functor &f,
ParameterContainer<void(P1,P2,P3,P4,P5,P6)> &parameters,
FunctionInterfaceReturnContainer<void> &,
const TransformFunctor &transform)
{
f(
transform(parameters.Parameter1),
transform(parameters.Parameter2),
transform(parameters.Parameter3),
transform(parameters.Parameter4),
transform(parameters.Parameter5),
transform(parameters.Parameter6));
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Functor,
typename TransformFunctor,
typename R,
typename P1,
typename P2,
typename P3,
typename P4,
typename P5,
typename P6,
typename P7>
VTKM_CONT_EXPORT
void DoInvokeCont(
const Functor &f,
ParameterContainer<R(P1,P2,P3,P4,P5,P6,P7)> &parameters,
FunctionInterfaceReturnContainer<R> &result,
const TransformFunctor &transform)
{
result.Value = transform(f(
transform(parameters.Parameter1),
transform(parameters.Parameter2),
transform(parameters.Parameter3),
transform(parameters.Parameter4),
transform(parameters.Parameter5),
transform(parameters.Parameter6),
transform(parameters.Parameter7)));
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Functor,
typename TransformFunctor,
typename P1,
typename P2,
typename P3,
typename P4,
typename P5,
typename P6,
typename P7>
VTKM_CONT_EXPORT
void DoInvokeCont(
const Functor &f,
ParameterContainer<void(P1,P2,P3,P4,P5,P6,P7)> &parameters,
FunctionInterfaceReturnContainer<void> &,
const TransformFunctor &transform)
{
f(
transform(parameters.Parameter1),
transform(parameters.Parameter2),
transform(parameters.Parameter3),
transform(parameters.Parameter4),
transform(parameters.Parameter5),
transform(parameters.Parameter6),
transform(parameters.Parameter7));
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Functor,
typename TransformFunctor,
typename R,
typename P1,
typename P2,
typename P3,
typename P4,
typename P5,
typename P6,
typename P7>
VTKM_CONT_EXPORT
void DoInvokeCont(
Functor &f,
ParameterContainer<R(P1,P2,P3,P4,P5,P6,P7)> &parameters,
FunctionInterfaceReturnContainer<R> &result,
const TransformFunctor &transform)
{
result.Value = transform(f(
transform(parameters.Parameter1),
transform(parameters.Parameter2),
transform(parameters.Parameter3),
transform(parameters.Parameter4),
transform(parameters.Parameter5),
transform(parameters.Parameter6),
transform(parameters.Parameter7)));
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Functor,
typename TransformFunctor,
typename P1,
typename P2,
typename P3,
typename P4,
typename P5,
typename P6,
typename P7>
VTKM_CONT_EXPORT
void DoInvokeCont(
Functor &f,
ParameterContainer<void(P1,P2,P3,P4,P5,P6,P7)> &parameters,
FunctionInterfaceReturnContainer<void> &,
const TransformFunctor &transform)
{
f(
transform(parameters.Parameter1),
transform(parameters.Parameter2),
transform(parameters.Parameter3),
transform(parameters.Parameter4),
transform(parameters.Parameter5),
transform(parameters.Parameter6),
transform(parameters.Parameter7));
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Functor,
typename TransformFunctor,
typename R,
typename P1,
typename P2,
typename P3,
typename P4,
typename P5,
typename P6,
typename P7>
VTKM_EXEC_EXPORT
void DoInvokeExec(
const Functor &f,
ParameterContainer<R(P1,P2,P3,P4,P5,P6,P7)> &parameters,
FunctionInterfaceReturnContainer<R> &result,
const TransformFunctor &transform)
{
result.Value = transform(f(
transform(parameters.Parameter1),
transform(parameters.Parameter2),
transform(parameters.Parameter3),
transform(parameters.Parameter4),
transform(parameters.Parameter5),
transform(parameters.Parameter6),
transform(parameters.Parameter7)));
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Functor,
typename TransformFunctor,
typename P1,
typename P2,
typename P3,
typename P4,
typename P5,
typename P6,
typename P7>
VTKM_EXEC_EXPORT
void DoInvokeExec(
const Functor &f,
ParameterContainer<void(P1,P2,P3,P4,P5,P6,P7)> &parameters,
FunctionInterfaceReturnContainer<void> &,
const TransformFunctor &transform)
{
f(
transform(parameters.Parameter1),
transform(parameters.Parameter2),
transform(parameters.Parameter3),
transform(parameters.Parameter4),
transform(parameters.Parameter5),
transform(parameters.Parameter6),
transform(parameters.Parameter7));
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Functor,
typename TransformFunctor,
typename R,
typename P1,
typename P2,
typename P3,
typename P4,
typename P5,
typename P6,
typename P7>
VTKM_EXEC_EXPORT
void DoInvokeExec(
Functor &f,
ParameterContainer<R(P1,P2,P3,P4,P5,P6,P7)> &parameters,
FunctionInterfaceReturnContainer<R> &result,
const TransformFunctor &transform)
{
result.Value = transform(f(
transform(parameters.Parameter1),
transform(parameters.Parameter2),
transform(parameters.Parameter3),
transform(parameters.Parameter4),
transform(parameters.Parameter5),
transform(parameters.Parameter6),
transform(parameters.Parameter7)));
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Functor,
typename TransformFunctor,
typename P1,
typename P2,
typename P3,
typename P4,
typename P5,
typename P6,
typename P7>
VTKM_EXEC_EXPORT
void DoInvokeExec(
Functor &f,
ParameterContainer<void(P1,P2,P3,P4,P5,P6,P7)> &parameters,
FunctionInterfaceReturnContainer<void> &,
const TransformFunctor &transform)
{
f(
transform(parameters.Parameter1),
transform(parameters.Parameter2),
transform(parameters.Parameter3),
transform(parameters.Parameter4),
transform(parameters.Parameter5),
transform(parameters.Parameter6),
transform(parameters.Parameter7));
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Functor,
typename TransformFunctor,
typename R,
typename P1,
typename P2,
typename P3,
typename P4,
typename P5,
typename P6,
typename P7,
typename P8>
VTKM_CONT_EXPORT
void DoInvokeCont(
const Functor &f,
ParameterContainer<R(P1,P2,P3,P4,P5,P6,P7,P8)> &parameters,
FunctionInterfaceReturnContainer<R> &result,
const TransformFunctor &transform)
{
result.Value = transform(f(
transform(parameters.Parameter1),
transform(parameters.Parameter2),
transform(parameters.Parameter3),
transform(parameters.Parameter4),
transform(parameters.Parameter5),
transform(parameters.Parameter6),
transform(parameters.Parameter7),
transform(parameters.Parameter8)));
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Functor,
typename TransformFunctor,
typename P1,
typename P2,
typename P3,
typename P4,
typename P5,
typename P6,
typename P7,
typename P8>
VTKM_CONT_EXPORT
void DoInvokeCont(
const Functor &f,
ParameterContainer<void(P1,P2,P3,P4,P5,P6,P7,P8)> &parameters,
FunctionInterfaceReturnContainer<void> &,
const TransformFunctor &transform)
{
f(
transform(parameters.Parameter1),
transform(parameters.Parameter2),
transform(parameters.Parameter3),
transform(parameters.Parameter4),
transform(parameters.Parameter5),
transform(parameters.Parameter6),
transform(parameters.Parameter7),
transform(parameters.Parameter8));
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Functor,
typename TransformFunctor,
typename R,
typename P1,
typename P2,
typename P3,
typename P4,
typename P5,
typename P6,
typename P7,
typename P8>
VTKM_CONT_EXPORT
void DoInvokeCont(
Functor &f,
ParameterContainer<R(P1,P2,P3,P4,P5,P6,P7,P8)> &parameters,
FunctionInterfaceReturnContainer<R> &result,
const TransformFunctor &transform)
{
result.Value = transform(f(
transform(parameters.Parameter1),
transform(parameters.Parameter2),
transform(parameters.Parameter3),
transform(parameters.Parameter4),
transform(parameters.Parameter5),
transform(parameters.Parameter6),
transform(parameters.Parameter7),
transform(parameters.Parameter8)));
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Functor,
typename TransformFunctor,
typename P1,
typename P2,
typename P3,
typename P4,
typename P5,
typename P6,
typename P7,
typename P8>
VTKM_CONT_EXPORT
void DoInvokeCont(
Functor &f,
ParameterContainer<void(P1,P2,P3,P4,P5,P6,P7,P8)> &parameters,
FunctionInterfaceReturnContainer<void> &,
const TransformFunctor &transform)
{
f(
transform(parameters.Parameter1),
transform(parameters.Parameter2),
transform(parameters.Parameter3),
transform(parameters.Parameter4),
transform(parameters.Parameter5),
transform(parameters.Parameter6),
transform(parameters.Parameter7),
transform(parameters.Parameter8));
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Functor,
typename TransformFunctor,
typename R,
typename P1,
typename P2,
typename P3,
typename P4,
typename P5,
typename P6,
typename P7,
typename P8>
VTKM_EXEC_EXPORT
void DoInvokeExec(
const Functor &f,
ParameterContainer<R(P1,P2,P3,P4,P5,P6,P7,P8)> &parameters,
FunctionInterfaceReturnContainer<R> &result,
const TransformFunctor &transform)
{
result.Value = transform(f(
transform(parameters.Parameter1),
transform(parameters.Parameter2),
transform(parameters.Parameter3),
transform(parameters.Parameter4),
transform(parameters.Parameter5),
transform(parameters.Parameter6),
transform(parameters.Parameter7),
transform(parameters.Parameter8)));
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Functor,
typename TransformFunctor,
typename P1,
typename P2,
typename P3,
typename P4,
typename P5,
typename P6,
typename P7,
typename P8>
VTKM_EXEC_EXPORT
void DoInvokeExec(
const Functor &f,
ParameterContainer<void(P1,P2,P3,P4,P5,P6,P7,P8)> &parameters,
FunctionInterfaceReturnContainer<void> &,
const TransformFunctor &transform)
{
f(
transform(parameters.Parameter1),
transform(parameters.Parameter2),
transform(parameters.Parameter3),
transform(parameters.Parameter4),
transform(parameters.Parameter5),
transform(parameters.Parameter6),
transform(parameters.Parameter7),
transform(parameters.Parameter8));
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Functor,
typename TransformFunctor,
typename R,
typename P1,
typename P2,
typename P3,
typename P4,
typename P5,
typename P6,
typename P7,
typename P8>
VTKM_EXEC_EXPORT
void DoInvokeExec(
Functor &f,
ParameterContainer<R(P1,P2,P3,P4,P5,P6,P7,P8)> &parameters,
FunctionInterfaceReturnContainer<R> &result,
const TransformFunctor &transform)
{
result.Value = transform(f(
transform(parameters.Parameter1),
transform(parameters.Parameter2),
transform(parameters.Parameter3),
transform(parameters.Parameter4),
transform(parameters.Parameter5),
transform(parameters.Parameter6),
transform(parameters.Parameter7),
transform(parameters.Parameter8)));
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Functor,
typename TransformFunctor,
typename P1,
typename P2,
typename P3,
typename P4,
typename P5,
typename P6,
typename P7,
typename P8>
VTKM_EXEC_EXPORT
void DoInvokeExec(
Functor &f,
ParameterContainer<void(P1,P2,P3,P4,P5,P6,P7,P8)> &parameters,
FunctionInterfaceReturnContainer<void> &,
const TransformFunctor &transform)
{
f(
transform(parameters.Parameter1),
transform(parameters.Parameter2),
transform(parameters.Parameter3),
transform(parameters.Parameter4),
transform(parameters.Parameter5),
transform(parameters.Parameter6),
transform(parameters.Parameter7),
transform(parameters.Parameter8));
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Functor,
typename TransformFunctor,
typename R,
typename P1,
typename P2,
typename P3,
typename P4,
typename P5,
typename P6,
typename P7,
typename P8,
typename P9>
VTKM_CONT_EXPORT
void DoInvokeCont(
const Functor &f,
ParameterContainer<R(P1,P2,P3,P4,P5,P6,P7,P8,P9)> &parameters,
FunctionInterfaceReturnContainer<R> &result,
const TransformFunctor &transform)
{
result.Value = transform(f(
transform(parameters.Parameter1),
transform(parameters.Parameter2),
transform(parameters.Parameter3),
transform(parameters.Parameter4),
transform(parameters.Parameter5),
transform(parameters.Parameter6),
transform(parameters.Parameter7),
transform(parameters.Parameter8),
transform(parameters.Parameter9)));
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Functor,
typename TransformFunctor,
typename P1,
typename P2,
typename P3,
typename P4,
typename P5,
typename P6,
typename P7,
typename P8,
typename P9>
VTKM_CONT_EXPORT
void DoInvokeCont(
const Functor &f,
ParameterContainer<void(P1,P2,P3,P4,P5,P6,P7,P8,P9)> &parameters,
FunctionInterfaceReturnContainer<void> &,
const TransformFunctor &transform)
{
f(
transform(parameters.Parameter1),
transform(parameters.Parameter2),
transform(parameters.Parameter3),
transform(parameters.Parameter4),
transform(parameters.Parameter5),
transform(parameters.Parameter6),
transform(parameters.Parameter7),
transform(parameters.Parameter8),
transform(parameters.Parameter9));
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Functor,
typename TransformFunctor,
typename R,
typename P1,
typename P2,
typename P3,
typename P4,
typename P5,
typename P6,
typename P7,
typename P8,
typename P9>
VTKM_CONT_EXPORT
void DoInvokeCont(
Functor &f,
ParameterContainer<R(P1,P2,P3,P4,P5,P6,P7,P8,P9)> &parameters,
FunctionInterfaceReturnContainer<R> &result,
const TransformFunctor &transform)
{
result.Value = transform(f(
transform(parameters.Parameter1),
transform(parameters.Parameter2),
transform(parameters.Parameter3),
transform(parameters.Parameter4),
transform(parameters.Parameter5),
transform(parameters.Parameter6),
transform(parameters.Parameter7),
transform(parameters.Parameter8),
transform(parameters.Parameter9)));
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Functor,
typename TransformFunctor,
typename P1,
typename P2,
typename P3,
typename P4,
typename P5,
typename P6,
typename P7,
typename P8,
typename P9>
VTKM_CONT_EXPORT
void DoInvokeCont(
Functor &f,
ParameterContainer<void(P1,P2,P3,P4,P5,P6,P7,P8,P9)> &parameters,
FunctionInterfaceReturnContainer<void> &,
const TransformFunctor &transform)
{
f(
transform(parameters.Parameter1),
transform(parameters.Parameter2),
transform(parameters.Parameter3),
transform(parameters.Parameter4),
transform(parameters.Parameter5),
transform(parameters.Parameter6),
transform(parameters.Parameter7),
transform(parameters.Parameter8),
transform(parameters.Parameter9));
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Functor,
typename TransformFunctor,
typename R,
typename P1,
typename P2,
typename P3,
typename P4,
typename P5,
typename P6,
typename P7,
typename P8,
typename P9>
VTKM_EXEC_EXPORT
void DoInvokeExec(
const Functor &f,
ParameterContainer<R(P1,P2,P3,P4,P5,P6,P7,P8,P9)> &parameters,
FunctionInterfaceReturnContainer<R> &result,
const TransformFunctor &transform)
{
result.Value = transform(f(
transform(parameters.Parameter1),
transform(parameters.Parameter2),
transform(parameters.Parameter3),
transform(parameters.Parameter4),
transform(parameters.Parameter5),
transform(parameters.Parameter6),
transform(parameters.Parameter7),
transform(parameters.Parameter8),
transform(parameters.Parameter9)));
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Functor,
typename TransformFunctor,
typename P1,
typename P2,
typename P3,
typename P4,
typename P5,
typename P6,
typename P7,
typename P8,
typename P9>
VTKM_EXEC_EXPORT
void DoInvokeExec(
const Functor &f,
ParameterContainer<void(P1,P2,P3,P4,P5,P6,P7,P8,P9)> &parameters,
FunctionInterfaceReturnContainer<void> &,
const TransformFunctor &transform)
{
f(
transform(parameters.Parameter1),
transform(parameters.Parameter2),
transform(parameters.Parameter3),
transform(parameters.Parameter4),
transform(parameters.Parameter5),
transform(parameters.Parameter6),
transform(parameters.Parameter7),
transform(parameters.Parameter8),
transform(parameters.Parameter9));
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Functor,
typename TransformFunctor,
typename R,
typename P1,
typename P2,
typename P3,
typename P4,
typename P5,
typename P6,
typename P7,
typename P8,
typename P9>
VTKM_EXEC_EXPORT
void DoInvokeExec(
Functor &f,
ParameterContainer<R(P1,P2,P3,P4,P5,P6,P7,P8,P9)> &parameters,
FunctionInterfaceReturnContainer<R> &result,
const TransformFunctor &transform)
{
result.Value = transform(f(
transform(parameters.Parameter1),
transform(parameters.Parameter2),
transform(parameters.Parameter3),
transform(parameters.Parameter4),
transform(parameters.Parameter5),
transform(parameters.Parameter6),
transform(parameters.Parameter7),
transform(parameters.Parameter8),
transform(parameters.Parameter9)));
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Functor,
typename TransformFunctor,
typename P1,
typename P2,
typename P3,
typename P4,
typename P5,
typename P6,
typename P7,
typename P8,
typename P9>
VTKM_EXEC_EXPORT
void DoInvokeExec(
Functor &f,
ParameterContainer<void(P1,P2,P3,P4,P5,P6,P7,P8,P9)> &parameters,
FunctionInterfaceReturnContainer<void> &,
const TransformFunctor &transform)
{
f(
transform(parameters.Parameter1),
transform(parameters.Parameter2),
transform(parameters.Parameter3),
transform(parameters.Parameter4),
transform(parameters.Parameter5),
transform(parameters.Parameter6),
transform(parameters.Parameter7),
transform(parameters.Parameter8),
transform(parameters.Parameter9));
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Functor,
typename TransformFunctor,
typename R,
typename P1,
typename P2,
typename P3,
typename P4,
typename P5,
typename P6,
typename P7,
typename P8,
typename P9,
typename P10>
VTKM_CONT_EXPORT
void DoInvokeCont(
const Functor &f,
ParameterContainer<R(P1,P2,P3,P4,P5,P6,P7,P8,P9,P10)> &parameters,
FunctionInterfaceReturnContainer<R> &result,
const TransformFunctor &transform)
{
result.Value = transform(f(
transform(parameters.Parameter1),
transform(parameters.Parameter2),
transform(parameters.Parameter3),
transform(parameters.Parameter4),
transform(parameters.Parameter5),
transform(parameters.Parameter6),
transform(parameters.Parameter7),
transform(parameters.Parameter8),
transform(parameters.Parameter9),
transform(parameters.Parameter10)));
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Functor,
typename TransformFunctor,
typename P1,
typename P2,
typename P3,
typename P4,
typename P5,
typename P6,
typename P7,
typename P8,
typename P9,
typename P10>
VTKM_CONT_EXPORT
void DoInvokeCont(
const Functor &f,
ParameterContainer<void(P1,P2,P3,P4,P5,P6,P7,P8,P9,P10)> &parameters,
FunctionInterfaceReturnContainer<void> &,
const TransformFunctor &transform)
{
f(
transform(parameters.Parameter1),
transform(parameters.Parameter2),
transform(parameters.Parameter3),
transform(parameters.Parameter4),
transform(parameters.Parameter5),
transform(parameters.Parameter6),
transform(parameters.Parameter7),
transform(parameters.Parameter8),
transform(parameters.Parameter9),
transform(parameters.Parameter10));
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Functor,
typename TransformFunctor,
typename R,
typename P1,
typename P2,
typename P3,
typename P4,
typename P5,
typename P6,
typename P7,
typename P8,
typename P9,
typename P10>
VTKM_CONT_EXPORT
void DoInvokeCont(
Functor &f,
ParameterContainer<R(P1,P2,P3,P4,P5,P6,P7,P8,P9,P10)> &parameters,
FunctionInterfaceReturnContainer<R> &result,
const TransformFunctor &transform)
{
result.Value = transform(f(
transform(parameters.Parameter1),
transform(parameters.Parameter2),
transform(parameters.Parameter3),
transform(parameters.Parameter4),
transform(parameters.Parameter5),
transform(parameters.Parameter6),
transform(parameters.Parameter7),
transform(parameters.Parameter8),
transform(parameters.Parameter9),
transform(parameters.Parameter10)));
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Functor,
typename TransformFunctor,
typename P1,
typename P2,
typename P3,
typename P4,
typename P5,
typename P6,
typename P7,
typename P8,
typename P9,
typename P10>
VTKM_CONT_EXPORT
void DoInvokeCont(
Functor &f,
ParameterContainer<void(P1,P2,P3,P4,P5,P6,P7,P8,P9,P10)> &parameters,
FunctionInterfaceReturnContainer<void> &,
const TransformFunctor &transform)
{
f(
transform(parameters.Parameter1),
transform(parameters.Parameter2),
transform(parameters.Parameter3),
transform(parameters.Parameter4),
transform(parameters.Parameter5),
transform(parameters.Parameter6),
transform(parameters.Parameter7),
transform(parameters.Parameter8),
transform(parameters.Parameter9),
transform(parameters.Parameter10));
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Functor,
typename TransformFunctor,
typename R,
typename P1,
typename P2,
typename P3,
typename P4,
typename P5,
typename P6,
typename P7,
typename P8,
typename P9,
typename P10>
VTKM_EXEC_EXPORT
void DoInvokeExec(
const Functor &f,
ParameterContainer<R(P1,P2,P3,P4,P5,P6,P7,P8,P9,P10)> &parameters,
FunctionInterfaceReturnContainer<R> &result,
const TransformFunctor &transform)
{
result.Value = transform(f(
transform(parameters.Parameter1),
transform(parameters.Parameter2),
transform(parameters.Parameter3),
transform(parameters.Parameter4),
transform(parameters.Parameter5),
transform(parameters.Parameter6),
transform(parameters.Parameter7),
transform(parameters.Parameter8),
transform(parameters.Parameter9),
transform(parameters.Parameter10)));
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Functor,
typename TransformFunctor,
typename P1,
typename P2,
typename P3,
typename P4,
typename P5,
typename P6,
typename P7,
typename P8,
typename P9,
typename P10>
VTKM_EXEC_EXPORT
void DoInvokeExec(
const Functor &f,
ParameterContainer<void(P1,P2,P3,P4,P5,P6,P7,P8,P9,P10)> &parameters,
FunctionInterfaceReturnContainer<void> &,
const TransformFunctor &transform)
{
f(
transform(parameters.Parameter1),
transform(parameters.Parameter2),
transform(parameters.Parameter3),
transform(parameters.Parameter4),
transform(parameters.Parameter5),
transform(parameters.Parameter6),
transform(parameters.Parameter7),
transform(parameters.Parameter8),
transform(parameters.Parameter9),
transform(parameters.Parameter10));
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Functor,
typename TransformFunctor,
typename R,
typename P1,
typename P2,
typename P3,
typename P4,
typename P5,
typename P6,
typename P7,
typename P8,
typename P9,
typename P10>
VTKM_EXEC_EXPORT
void DoInvokeExec(
Functor &f,
ParameterContainer<R(P1,P2,P3,P4,P5,P6,P7,P8,P9,P10)> &parameters,
FunctionInterfaceReturnContainer<R> &result,
const TransformFunctor &transform)
{
result.Value = transform(f(
transform(parameters.Parameter1),
transform(parameters.Parameter2),
transform(parameters.Parameter3),
transform(parameters.Parameter4),
transform(parameters.Parameter5),
transform(parameters.Parameter6),
transform(parameters.Parameter7),
transform(parameters.Parameter8),
transform(parameters.Parameter9),
transform(parameters.Parameter10)));
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Functor,
typename TransformFunctor,
typename P1,
typename P2,
typename P3,
typename P4,
typename P5,
typename P6,
typename P7,
typename P8,
typename P9,
typename P10>
VTKM_EXEC_EXPORT
void DoInvokeExec(
Functor &f,
ParameterContainer<void(P1,P2,P3,P4,P5,P6,P7,P8,P9,P10)> &parameters,
FunctionInterfaceReturnContainer<void> &,
const TransformFunctor &transform)
{
f(
transform(parameters.Parameter1),
transform(parameters.Parameter2),
transform(parameters.Parameter3),
transform(parameters.Parameter4),
transform(parameters.Parameter5),
transform(parameters.Parameter6),
transform(parameters.Parameter7),
transform(parameters.Parameter8),
transform(parameters.Parameter9),
transform(parameters.Parameter10));
}
//============================================================================
template<typename OriginalSignature, typename Transform>
struct FunctionInterfaceStaticTransformType;
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Transform,
typename OriginalR,
typename TransformedR>
VTKM_CONT_EXPORT
void DoStaticTransformCont(
const Transform &transform,
const ParameterContainer<OriginalR()> &originalParameters,
ParameterContainer<TransformedR()> &transformedParameters)
{
(void)transform;
(void)originalParameters;
(void)transformedParameters;
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Transform,
typename OriginalR,
typename TransformedR>
VTKM_EXEC_EXPORT
void DoStaticTransformExec(
const Transform &transform,
const ParameterContainer<OriginalR()> &originalParameters,
ParameterContainer<TransformedR()> &transformedParameters)
{
(void)transform;
(void)originalParameters;
(void)transformedParameters;
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Transform,
typename OriginalR,
typename OriginalP1,
typename TransformedR,
typename TransformedP1>
VTKM_CONT_EXPORT
void DoStaticTransformCont(
const Transform &transform,
const ParameterContainer<OriginalR(OriginalP1)> &originalParameters,
ParameterContainer<TransformedR(TransformedP1)> &transformedParameters)
{
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
transformedParameters.Parameter1 =
transform(originalParameters.Parameter1, vtkm::internal::IndexTag<1>());
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Transform,
typename OriginalR,
typename OriginalP1,
typename TransformedR,
typename TransformedP1>
VTKM_EXEC_EXPORT
void DoStaticTransformExec(
const Transform &transform,
const ParameterContainer<OriginalR(OriginalP1)> &originalParameters,
ParameterContainer<TransformedR(TransformedP1)> &transformedParameters)
{
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
transformedParameters.Parameter1 =
transform(originalParameters.Parameter1, vtkm::internal::IndexTag<1>());
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Transform,
typename OriginalR,
typename OriginalP1,
typename OriginalP2,
typename TransformedR,
typename TransformedP1,
typename TransformedP2>
VTKM_CONT_EXPORT
void DoStaticTransformCont(
const Transform &transform,
const ParameterContainer<OriginalR(OriginalP1,OriginalP2)> &originalParameters,
ParameterContainer<TransformedR(TransformedP1,TransformedP2)> &transformedParameters)
{
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
transformedParameters.Parameter1 =
transform(originalParameters.Parameter1, vtkm::internal::IndexTag<1>());
transformedParameters.Parameter2 =
transform(originalParameters.Parameter2, vtkm::internal::IndexTag<2>());
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Transform,
typename OriginalR,
typename OriginalP1,
typename OriginalP2,
typename TransformedR,
typename TransformedP1,
typename TransformedP2>
VTKM_EXEC_EXPORT
void DoStaticTransformExec(
const Transform &transform,
const ParameterContainer<OriginalR(OriginalP1,OriginalP2)> &originalParameters,
ParameterContainer<TransformedR(TransformedP1,TransformedP2)> &transformedParameters)
{
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
transformedParameters.Parameter1 =
transform(originalParameters.Parameter1, vtkm::internal::IndexTag<1>());
transformedParameters.Parameter2 =
transform(originalParameters.Parameter2, vtkm::internal::IndexTag<2>());
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Transform,
typename OriginalR,
typename OriginalP1,
typename OriginalP2,
typename OriginalP3,
typename TransformedR,
typename TransformedP1,
typename TransformedP2,
typename TransformedP3>
VTKM_CONT_EXPORT
void DoStaticTransformCont(
const Transform &transform,
const ParameterContainer<OriginalR(OriginalP1,OriginalP2,OriginalP3)> &originalParameters,
ParameterContainer<TransformedR(TransformedP1,TransformedP2,TransformedP3)> &transformedParameters)
{
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
transformedParameters.Parameter1 =
transform(originalParameters.Parameter1, vtkm::internal::IndexTag<1>());
transformedParameters.Parameter2 =
transform(originalParameters.Parameter2, vtkm::internal::IndexTag<2>());
transformedParameters.Parameter3 =
transform(originalParameters.Parameter3, vtkm::internal::IndexTag<3>());
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Transform,
typename OriginalR,
typename OriginalP1,
typename OriginalP2,
typename OriginalP3,
typename TransformedR,
typename TransformedP1,
typename TransformedP2,
typename TransformedP3>
VTKM_EXEC_EXPORT
void DoStaticTransformExec(
const Transform &transform,
const ParameterContainer<OriginalR(OriginalP1,OriginalP2,OriginalP3)> &originalParameters,
ParameterContainer<TransformedR(TransformedP1,TransformedP2,TransformedP3)> &transformedParameters)
{
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
transformedParameters.Parameter1 =
transform(originalParameters.Parameter1, vtkm::internal::IndexTag<1>());
transformedParameters.Parameter2 =
transform(originalParameters.Parameter2, vtkm::internal::IndexTag<2>());
transformedParameters.Parameter3 =
transform(originalParameters.Parameter3, vtkm::internal::IndexTag<3>());
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Transform,
typename OriginalR,
typename OriginalP1,
typename OriginalP2,
typename OriginalP3,
typename OriginalP4,
typename TransformedR,
typename TransformedP1,
typename TransformedP2,
typename TransformedP3,
typename TransformedP4>
VTKM_CONT_EXPORT
void DoStaticTransformCont(
const Transform &transform,
const ParameterContainer<OriginalR(OriginalP1,OriginalP2,OriginalP3,OriginalP4)> &originalParameters,
ParameterContainer<TransformedR(TransformedP1,TransformedP2,TransformedP3,TransformedP4)> &transformedParameters)
{
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
transformedParameters.Parameter1 =
transform(originalParameters.Parameter1, vtkm::internal::IndexTag<1>());
transformedParameters.Parameter2 =
transform(originalParameters.Parameter2, vtkm::internal::IndexTag<2>());
transformedParameters.Parameter3 =
transform(originalParameters.Parameter3, vtkm::internal::IndexTag<3>());
transformedParameters.Parameter4 =
transform(originalParameters.Parameter4, vtkm::internal::IndexTag<4>());
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Transform,
typename OriginalR,
typename OriginalP1,
typename OriginalP2,
typename OriginalP3,
typename OriginalP4,
typename TransformedR,
typename TransformedP1,
typename TransformedP2,
typename TransformedP3,
typename TransformedP4>
VTKM_EXEC_EXPORT
void DoStaticTransformExec(
const Transform &transform,
const ParameterContainer<OriginalR(OriginalP1,OriginalP2,OriginalP3,OriginalP4)> &originalParameters,
ParameterContainer<TransformedR(TransformedP1,TransformedP2,TransformedP3,TransformedP4)> &transformedParameters)
{
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
transformedParameters.Parameter1 =
transform(originalParameters.Parameter1, vtkm::internal::IndexTag<1>());
transformedParameters.Parameter2 =
transform(originalParameters.Parameter2, vtkm::internal::IndexTag<2>());
transformedParameters.Parameter3 =
transform(originalParameters.Parameter3, vtkm::internal::IndexTag<3>());
transformedParameters.Parameter4 =
transform(originalParameters.Parameter4, vtkm::internal::IndexTag<4>());
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Transform,
typename OriginalR,
typename OriginalP1,
typename OriginalP2,
typename OriginalP3,
typename OriginalP4,
typename OriginalP5,
typename TransformedR,
typename TransformedP1,
typename TransformedP2,
typename TransformedP3,
typename TransformedP4,
typename TransformedP5>
VTKM_CONT_EXPORT
void DoStaticTransformCont(
const Transform &transform,
const ParameterContainer<OriginalR(OriginalP1,OriginalP2,OriginalP3,OriginalP4,OriginalP5)> &originalParameters,
ParameterContainer<TransformedR(TransformedP1,TransformedP2,TransformedP3,TransformedP4,TransformedP5)> &transformedParameters)
{
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
transformedParameters.Parameter1 =
transform(originalParameters.Parameter1, vtkm::internal::IndexTag<1>());
transformedParameters.Parameter2 =
transform(originalParameters.Parameter2, vtkm::internal::IndexTag<2>());
transformedParameters.Parameter3 =
transform(originalParameters.Parameter3, vtkm::internal::IndexTag<3>());
transformedParameters.Parameter4 =
transform(originalParameters.Parameter4, vtkm::internal::IndexTag<4>());
transformedParameters.Parameter5 =
transform(originalParameters.Parameter5, vtkm::internal::IndexTag<5>());
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Transform,
typename OriginalR,
typename OriginalP1,
typename OriginalP2,
typename OriginalP3,
typename OriginalP4,
typename OriginalP5,
typename TransformedR,
typename TransformedP1,
typename TransformedP2,
typename TransformedP3,
typename TransformedP4,
typename TransformedP5>
VTKM_EXEC_EXPORT
void DoStaticTransformExec(
const Transform &transform,
const ParameterContainer<OriginalR(OriginalP1,OriginalP2,OriginalP3,OriginalP4,OriginalP5)> &originalParameters,
ParameterContainer<TransformedR(TransformedP1,TransformedP2,TransformedP3,TransformedP4,TransformedP5)> &transformedParameters)
{
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
transformedParameters.Parameter1 =
transform(originalParameters.Parameter1, vtkm::internal::IndexTag<1>());
transformedParameters.Parameter2 =
transform(originalParameters.Parameter2, vtkm::internal::IndexTag<2>());
transformedParameters.Parameter3 =
transform(originalParameters.Parameter3, vtkm::internal::IndexTag<3>());
transformedParameters.Parameter4 =
transform(originalParameters.Parameter4, vtkm::internal::IndexTag<4>());
transformedParameters.Parameter5 =
transform(originalParameters.Parameter5, vtkm::internal::IndexTag<5>());
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Transform,
typename OriginalR,
typename OriginalP1,
typename OriginalP2,
typename OriginalP3,
typename OriginalP4,
typename OriginalP5,
typename OriginalP6,
typename TransformedR,
typename TransformedP1,
typename TransformedP2,
typename TransformedP3,
typename TransformedP4,
typename TransformedP5,
typename TransformedP6>
VTKM_CONT_EXPORT
void DoStaticTransformCont(
const Transform &transform,
const ParameterContainer<OriginalR(OriginalP1,OriginalP2,OriginalP3,OriginalP4,OriginalP5,OriginalP6)> &originalParameters,
ParameterContainer<TransformedR(TransformedP1,TransformedP2,TransformedP3,TransformedP4,TransformedP5,TransformedP6)> &transformedParameters)
{
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
transformedParameters.Parameter1 =
transform(originalParameters.Parameter1, vtkm::internal::IndexTag<1>());
transformedParameters.Parameter2 =
transform(originalParameters.Parameter2, vtkm::internal::IndexTag<2>());
transformedParameters.Parameter3 =
transform(originalParameters.Parameter3, vtkm::internal::IndexTag<3>());
transformedParameters.Parameter4 =
transform(originalParameters.Parameter4, vtkm::internal::IndexTag<4>());
transformedParameters.Parameter5 =
transform(originalParameters.Parameter5, vtkm::internal::IndexTag<5>());
transformedParameters.Parameter6 =
transform(originalParameters.Parameter6, vtkm::internal::IndexTag<6>());
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Transform,
typename OriginalR,
typename OriginalP1,
typename OriginalP2,
typename OriginalP3,
typename OriginalP4,
typename OriginalP5,
typename OriginalP6,
typename TransformedR,
typename TransformedP1,
typename TransformedP2,
typename TransformedP3,
typename TransformedP4,
typename TransformedP5,
typename TransformedP6>
VTKM_EXEC_EXPORT
void DoStaticTransformExec(
const Transform &transform,
const ParameterContainer<OriginalR(OriginalP1,OriginalP2,OriginalP3,OriginalP4,OriginalP5,OriginalP6)> &originalParameters,
ParameterContainer<TransformedR(TransformedP1,TransformedP2,TransformedP3,TransformedP4,TransformedP5,TransformedP6)> &transformedParameters)
{
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
transformedParameters.Parameter1 =
transform(originalParameters.Parameter1, vtkm::internal::IndexTag<1>());
transformedParameters.Parameter2 =
transform(originalParameters.Parameter2, vtkm::internal::IndexTag<2>());
transformedParameters.Parameter3 =
transform(originalParameters.Parameter3, vtkm::internal::IndexTag<3>());
transformedParameters.Parameter4 =
transform(originalParameters.Parameter4, vtkm::internal::IndexTag<4>());
transformedParameters.Parameter5 =
transform(originalParameters.Parameter5, vtkm::internal::IndexTag<5>());
transformedParameters.Parameter6 =
transform(originalParameters.Parameter6, vtkm::internal::IndexTag<6>());
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Transform,
typename OriginalR,
typename OriginalP1,
typename OriginalP2,
typename OriginalP3,
typename OriginalP4,
typename OriginalP5,
typename OriginalP6,
typename OriginalP7,
typename TransformedR,
typename TransformedP1,
typename TransformedP2,
typename TransformedP3,
typename TransformedP4,
typename TransformedP5,
typename TransformedP6,
typename TransformedP7>
VTKM_CONT_EXPORT
void DoStaticTransformCont(
const Transform &transform,
const ParameterContainer<OriginalR(OriginalP1,OriginalP2,OriginalP3,OriginalP4,OriginalP5,OriginalP6,OriginalP7)> &originalParameters,
ParameterContainer<TransformedR(TransformedP1,TransformedP2,TransformedP3,TransformedP4,TransformedP5,TransformedP6,TransformedP7)> &transformedParameters)
{
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
transformedParameters.Parameter1 =
transform(originalParameters.Parameter1, vtkm::internal::IndexTag<1>());
transformedParameters.Parameter2 =
transform(originalParameters.Parameter2, vtkm::internal::IndexTag<2>());
transformedParameters.Parameter3 =
transform(originalParameters.Parameter3, vtkm::internal::IndexTag<3>());
transformedParameters.Parameter4 =
transform(originalParameters.Parameter4, vtkm::internal::IndexTag<4>());
transformedParameters.Parameter5 =
transform(originalParameters.Parameter5, vtkm::internal::IndexTag<5>());
transformedParameters.Parameter6 =
transform(originalParameters.Parameter6, vtkm::internal::IndexTag<6>());
transformedParameters.Parameter7 =
transform(originalParameters.Parameter7, vtkm::internal::IndexTag<7>());
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Transform,
typename OriginalR,
typename OriginalP1,
typename OriginalP2,
typename OriginalP3,
typename OriginalP4,
typename OriginalP5,
typename OriginalP6,
typename OriginalP7,
typename TransformedR,
typename TransformedP1,
typename TransformedP2,
typename TransformedP3,
typename TransformedP4,
typename TransformedP5,
typename TransformedP6,
typename TransformedP7>
VTKM_EXEC_EXPORT
void DoStaticTransformExec(
const Transform &transform,
const ParameterContainer<OriginalR(OriginalP1,OriginalP2,OriginalP3,OriginalP4,OriginalP5,OriginalP6,OriginalP7)> &originalParameters,
ParameterContainer<TransformedR(TransformedP1,TransformedP2,TransformedP3,TransformedP4,TransformedP5,TransformedP6,TransformedP7)> &transformedParameters)
{
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
transformedParameters.Parameter1 =
transform(originalParameters.Parameter1, vtkm::internal::IndexTag<1>());
transformedParameters.Parameter2 =
transform(originalParameters.Parameter2, vtkm::internal::IndexTag<2>());
transformedParameters.Parameter3 =
transform(originalParameters.Parameter3, vtkm::internal::IndexTag<3>());
transformedParameters.Parameter4 =
transform(originalParameters.Parameter4, vtkm::internal::IndexTag<4>());
transformedParameters.Parameter5 =
transform(originalParameters.Parameter5, vtkm::internal::IndexTag<5>());
transformedParameters.Parameter6 =
transform(originalParameters.Parameter6, vtkm::internal::IndexTag<6>());
transformedParameters.Parameter7 =
transform(originalParameters.Parameter7, vtkm::internal::IndexTag<7>());
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Transform,
typename OriginalR,
typename OriginalP1,
typename OriginalP2,
typename OriginalP3,
typename OriginalP4,
typename OriginalP5,
typename OriginalP6,
typename OriginalP7,
typename OriginalP8,
typename TransformedR,
typename TransformedP1,
typename TransformedP2,
typename TransformedP3,
typename TransformedP4,
typename TransformedP5,
typename TransformedP6,
typename TransformedP7,
typename TransformedP8>
VTKM_CONT_EXPORT
void DoStaticTransformCont(
const Transform &transform,
const ParameterContainer<OriginalR(OriginalP1,OriginalP2,OriginalP3,OriginalP4,OriginalP5,OriginalP6,OriginalP7,OriginalP8)> &originalParameters,
ParameterContainer<TransformedR(TransformedP1,TransformedP2,TransformedP3,TransformedP4,TransformedP5,TransformedP6,TransformedP7,TransformedP8)> &transformedParameters)
{
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
transformedParameters.Parameter1 =
transform(originalParameters.Parameter1, vtkm::internal::IndexTag<1>());
transformedParameters.Parameter2 =
transform(originalParameters.Parameter2, vtkm::internal::IndexTag<2>());
transformedParameters.Parameter3 =
transform(originalParameters.Parameter3, vtkm::internal::IndexTag<3>());
transformedParameters.Parameter4 =
transform(originalParameters.Parameter4, vtkm::internal::IndexTag<4>());
transformedParameters.Parameter5 =
transform(originalParameters.Parameter5, vtkm::internal::IndexTag<5>());
transformedParameters.Parameter6 =
transform(originalParameters.Parameter6, vtkm::internal::IndexTag<6>());
transformedParameters.Parameter7 =
transform(originalParameters.Parameter7, vtkm::internal::IndexTag<7>());
transformedParameters.Parameter8 =
transform(originalParameters.Parameter8, vtkm::internal::IndexTag<8>());
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Transform,
typename OriginalR,
typename OriginalP1,
typename OriginalP2,
typename OriginalP3,
typename OriginalP4,
typename OriginalP5,
typename OriginalP6,
typename OriginalP7,
typename OriginalP8,
typename TransformedR,
typename TransformedP1,
typename TransformedP2,
typename TransformedP3,
typename TransformedP4,
typename TransformedP5,
typename TransformedP6,
typename TransformedP7,
typename TransformedP8>
VTKM_EXEC_EXPORT
void DoStaticTransformExec(
const Transform &transform,
const ParameterContainer<OriginalR(OriginalP1,OriginalP2,OriginalP3,OriginalP4,OriginalP5,OriginalP6,OriginalP7,OriginalP8)> &originalParameters,
ParameterContainer<TransformedR(TransformedP1,TransformedP2,TransformedP3,TransformedP4,TransformedP5,TransformedP6,TransformedP7,TransformedP8)> &transformedParameters)
{
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
transformedParameters.Parameter1 =
transform(originalParameters.Parameter1, vtkm::internal::IndexTag<1>());
transformedParameters.Parameter2 =
transform(originalParameters.Parameter2, vtkm::internal::IndexTag<2>());
transformedParameters.Parameter3 =
transform(originalParameters.Parameter3, vtkm::internal::IndexTag<3>());
transformedParameters.Parameter4 =
transform(originalParameters.Parameter4, vtkm::internal::IndexTag<4>());
transformedParameters.Parameter5 =
transform(originalParameters.Parameter5, vtkm::internal::IndexTag<5>());
transformedParameters.Parameter6 =
transform(originalParameters.Parameter6, vtkm::internal::IndexTag<6>());
transformedParameters.Parameter7 =
transform(originalParameters.Parameter7, vtkm::internal::IndexTag<7>());
transformedParameters.Parameter8 =
transform(originalParameters.Parameter8, vtkm::internal::IndexTag<8>());
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Transform,
typename OriginalR,
typename OriginalP1,
typename OriginalP2,
typename OriginalP3,
typename OriginalP4,
typename OriginalP5,
typename OriginalP6,
typename OriginalP7,
typename OriginalP8,
typename OriginalP9,
typename TransformedR,
typename TransformedP1,
typename TransformedP2,
typename TransformedP3,
typename TransformedP4,
typename TransformedP5,
typename TransformedP6,
typename TransformedP7,
typename TransformedP8,
typename TransformedP9>
VTKM_CONT_EXPORT
void DoStaticTransformCont(
const Transform &transform,
const ParameterContainer<OriginalR(OriginalP1,OriginalP2,OriginalP3,OriginalP4,OriginalP5,OriginalP6,OriginalP7,OriginalP8,OriginalP9)> &originalParameters,
ParameterContainer<TransformedR(TransformedP1,TransformedP2,TransformedP3,TransformedP4,TransformedP5,TransformedP6,TransformedP7,TransformedP8,TransformedP9)> &transformedParameters)
{
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
transformedParameters.Parameter1 =
transform(originalParameters.Parameter1, vtkm::internal::IndexTag<1>());
transformedParameters.Parameter2 =
transform(originalParameters.Parameter2, vtkm::internal::IndexTag<2>());
transformedParameters.Parameter3 =
transform(originalParameters.Parameter3, vtkm::internal::IndexTag<3>());
transformedParameters.Parameter4 =
transform(originalParameters.Parameter4, vtkm::internal::IndexTag<4>());
transformedParameters.Parameter5 =
transform(originalParameters.Parameter5, vtkm::internal::IndexTag<5>());
transformedParameters.Parameter6 =
transform(originalParameters.Parameter6, vtkm::internal::IndexTag<6>());
transformedParameters.Parameter7 =
transform(originalParameters.Parameter7, vtkm::internal::IndexTag<7>());
transformedParameters.Parameter8 =
transform(originalParameters.Parameter8, vtkm::internal::IndexTag<8>());
transformedParameters.Parameter9 =
transform(originalParameters.Parameter9, vtkm::internal::IndexTag<9>());
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Transform,
typename OriginalR,
typename OriginalP1,
typename OriginalP2,
typename OriginalP3,
typename OriginalP4,
typename OriginalP5,
typename OriginalP6,
typename OriginalP7,
typename OriginalP8,
typename OriginalP9,
typename TransformedR,
typename TransformedP1,
typename TransformedP2,
typename TransformedP3,
typename TransformedP4,
typename TransformedP5,
typename TransformedP6,
typename TransformedP7,
typename TransformedP8,
typename TransformedP9>
VTKM_EXEC_EXPORT
void DoStaticTransformExec(
const Transform &transform,
const ParameterContainer<OriginalR(OriginalP1,OriginalP2,OriginalP3,OriginalP4,OriginalP5,OriginalP6,OriginalP7,OriginalP8,OriginalP9)> &originalParameters,
ParameterContainer<TransformedR(TransformedP1,TransformedP2,TransformedP3,TransformedP4,TransformedP5,TransformedP6,TransformedP7,TransformedP8,TransformedP9)> &transformedParameters)
{
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
transformedParameters.Parameter1 =
transform(originalParameters.Parameter1, vtkm::internal::IndexTag<1>());
transformedParameters.Parameter2 =
transform(originalParameters.Parameter2, vtkm::internal::IndexTag<2>());
transformedParameters.Parameter3 =
transform(originalParameters.Parameter3, vtkm::internal::IndexTag<3>());
transformedParameters.Parameter4 =
transform(originalParameters.Parameter4, vtkm::internal::IndexTag<4>());
transformedParameters.Parameter5 =
transform(originalParameters.Parameter5, vtkm::internal::IndexTag<5>());
transformedParameters.Parameter6 =
transform(originalParameters.Parameter6, vtkm::internal::IndexTag<6>());
transformedParameters.Parameter7 =
transform(originalParameters.Parameter7, vtkm::internal::IndexTag<7>());
transformedParameters.Parameter8 =
transform(originalParameters.Parameter8, vtkm::internal::IndexTag<8>());
transformedParameters.Parameter9 =
transform(originalParameters.Parameter9, vtkm::internal::IndexTag<9>());
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
}
//============================================================================
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Functor,
typename R>
VTKM_CONT_EXPORT
void DoForEachCont(
const Functor &f,
const ParameterContainer<R()> &parameters)
{
(void)f;
(void)parameters;
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Functor,
typename R>
VTKM_CONT_EXPORT
void DoForEachCont(
const Functor &f,
ParameterContainer<R()> &parameters)
{
(void)f;
(void)parameters;
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Functor,
typename R>
VTKM_EXEC_EXPORT
void DoForEachExec(
const Functor &f,
const ParameterContainer<R()> &parameters)
{
(void)f;
(void)parameters;
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Functor,
typename R>
VTKM_EXEC_EXPORT
void DoForEachExec(
const Functor &f,
ParameterContainer<R()> &parameters)
{
(void)f;
(void)parameters;
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Functor,
typename R,
typename P1>
VTKM_CONT_EXPORT
void DoForEachCont(
const Functor &f,
const ParameterContainer<R(P1)> &parameters)
{
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
f(parameters.Parameter1, vtkm::internal::IndexTag<1>());
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Functor,
typename R,
typename P1>
VTKM_CONT_EXPORT
void DoForEachCont(
const Functor &f,
ParameterContainer<R(P1)> &parameters)
{
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
f(parameters.Parameter1, vtkm::internal::IndexTag<1>());
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Functor,
typename R,
typename P1>
VTKM_EXEC_EXPORT
void DoForEachExec(
const Functor &f,
const ParameterContainer<R(P1)> &parameters)
{
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
f(parameters.Parameter1, vtkm::internal::IndexTag<1>());
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Functor,
typename R,
typename P1>
VTKM_EXEC_EXPORT
void DoForEachExec(
const Functor &f,
ParameterContainer<R(P1)> &parameters)
{
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
f(parameters.Parameter1, vtkm::internal::IndexTag<1>());
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Functor,
typename R,
typename P1,
typename P2>
VTKM_CONT_EXPORT
void DoForEachCont(
const Functor &f,
const ParameterContainer<R(P1,P2)> &parameters)
{
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
f(parameters.Parameter1, vtkm::internal::IndexTag<1>());
f(parameters.Parameter2, vtkm::internal::IndexTag<2>());
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Functor,
typename R,
typename P1,
typename P2>
VTKM_CONT_EXPORT
void DoForEachCont(
const Functor &f,
ParameterContainer<R(P1,P2)> &parameters)
{
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
f(parameters.Parameter1, vtkm::internal::IndexTag<1>());
f(parameters.Parameter2, vtkm::internal::IndexTag<2>());
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Functor,
typename R,
typename P1,
typename P2>
VTKM_EXEC_EXPORT
void DoForEachExec(
const Functor &f,
const ParameterContainer<R(P1,P2)> &parameters)
{
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
f(parameters.Parameter1, vtkm::internal::IndexTag<1>());
f(parameters.Parameter2, vtkm::internal::IndexTag<2>());
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Functor,
typename R,
typename P1,
typename P2>
VTKM_EXEC_EXPORT
void DoForEachExec(
const Functor &f,
ParameterContainer<R(P1,P2)> &parameters)
{
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
f(parameters.Parameter1, vtkm::internal::IndexTag<1>());
f(parameters.Parameter2, vtkm::internal::IndexTag<2>());
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Functor,
typename R,
typename P1,
typename P2,
typename P3>
VTKM_CONT_EXPORT
void DoForEachCont(
const Functor &f,
const ParameterContainer<R(P1,P2,P3)> &parameters)
{
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
f(parameters.Parameter1, vtkm::internal::IndexTag<1>());
f(parameters.Parameter2, vtkm::internal::IndexTag<2>());
f(parameters.Parameter3, vtkm::internal::IndexTag<3>());
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Functor,
typename R,
typename P1,
typename P2,
typename P3>
VTKM_CONT_EXPORT
void DoForEachCont(
const Functor &f,
ParameterContainer<R(P1,P2,P3)> &parameters)
{
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
f(parameters.Parameter1, vtkm::internal::IndexTag<1>());
f(parameters.Parameter2, vtkm::internal::IndexTag<2>());
f(parameters.Parameter3, vtkm::internal::IndexTag<3>());
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Functor,
typename R,
typename P1,
typename P2,
typename P3>
VTKM_EXEC_EXPORT
void DoForEachExec(
const Functor &f,
const ParameterContainer<R(P1,P2,P3)> &parameters)
{
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
f(parameters.Parameter1, vtkm::internal::IndexTag<1>());
f(parameters.Parameter2, vtkm::internal::IndexTag<2>());
f(parameters.Parameter3, vtkm::internal::IndexTag<3>());
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Functor,
typename R,
typename P1,
typename P2,
typename P3>
VTKM_EXEC_EXPORT
void DoForEachExec(
const Functor &f,
ParameterContainer<R(P1,P2,P3)> &parameters)
{
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
f(parameters.Parameter1, vtkm::internal::IndexTag<1>());
f(parameters.Parameter2, vtkm::internal::IndexTag<2>());
f(parameters.Parameter3, vtkm::internal::IndexTag<3>());
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Functor,
typename R,
typename P1,
typename P2,
typename P3,
typename P4>
VTKM_CONT_EXPORT
void DoForEachCont(
const Functor &f,
const ParameterContainer<R(P1,P2,P3,P4)> &parameters)
{
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
f(parameters.Parameter1, vtkm::internal::IndexTag<1>());
f(parameters.Parameter2, vtkm::internal::IndexTag<2>());
f(parameters.Parameter3, vtkm::internal::IndexTag<3>());
f(parameters.Parameter4, vtkm::internal::IndexTag<4>());
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Functor,
typename R,
typename P1,
typename P2,
typename P3,
typename P4>
VTKM_CONT_EXPORT
void DoForEachCont(
const Functor &f,
ParameterContainer<R(P1,P2,P3,P4)> &parameters)
{
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
f(parameters.Parameter1, vtkm::internal::IndexTag<1>());
f(parameters.Parameter2, vtkm::internal::IndexTag<2>());
f(parameters.Parameter3, vtkm::internal::IndexTag<3>());
f(parameters.Parameter4, vtkm::internal::IndexTag<4>());
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Functor,
typename R,
typename P1,
typename P2,
typename P3,
typename P4>
VTKM_EXEC_EXPORT
void DoForEachExec(
const Functor &f,
const ParameterContainer<R(P1,P2,P3,P4)> &parameters)
{
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
f(parameters.Parameter1, vtkm::internal::IndexTag<1>());
f(parameters.Parameter2, vtkm::internal::IndexTag<2>());
f(parameters.Parameter3, vtkm::internal::IndexTag<3>());
f(parameters.Parameter4, vtkm::internal::IndexTag<4>());
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Functor,
typename R,
typename P1,
typename P2,
typename P3,
typename P4>
VTKM_EXEC_EXPORT
void DoForEachExec(
const Functor &f,
ParameterContainer<R(P1,P2,P3,P4)> &parameters)
{
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
f(parameters.Parameter1, vtkm::internal::IndexTag<1>());
f(parameters.Parameter2, vtkm::internal::IndexTag<2>());
f(parameters.Parameter3, vtkm::internal::IndexTag<3>());
f(parameters.Parameter4, vtkm::internal::IndexTag<4>());
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Functor,
typename R,
typename P1,
typename P2,
typename P3,
typename P4,
typename P5>
VTKM_CONT_EXPORT
void DoForEachCont(
const Functor &f,
const ParameterContainer<R(P1,P2,P3,P4,P5)> &parameters)
{
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
f(parameters.Parameter1, vtkm::internal::IndexTag<1>());
f(parameters.Parameter2, vtkm::internal::IndexTag<2>());
f(parameters.Parameter3, vtkm::internal::IndexTag<3>());
f(parameters.Parameter4, vtkm::internal::IndexTag<4>());
f(parameters.Parameter5, vtkm::internal::IndexTag<5>());
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Functor,
typename R,
typename P1,
typename P2,
typename P3,
typename P4,
typename P5>
VTKM_CONT_EXPORT
void DoForEachCont(
const Functor &f,
ParameterContainer<R(P1,P2,P3,P4,P5)> &parameters)
{
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
f(parameters.Parameter1, vtkm::internal::IndexTag<1>());
f(parameters.Parameter2, vtkm::internal::IndexTag<2>());
f(parameters.Parameter3, vtkm::internal::IndexTag<3>());
f(parameters.Parameter4, vtkm::internal::IndexTag<4>());
f(parameters.Parameter5, vtkm::internal::IndexTag<5>());
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Functor,
typename R,
typename P1,
typename P2,
typename P3,
typename P4,
typename P5>
VTKM_EXEC_EXPORT
void DoForEachExec(
const Functor &f,
const ParameterContainer<R(P1,P2,P3,P4,P5)> &parameters)
{
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
f(parameters.Parameter1, vtkm::internal::IndexTag<1>());
f(parameters.Parameter2, vtkm::internal::IndexTag<2>());
f(parameters.Parameter3, vtkm::internal::IndexTag<3>());
f(parameters.Parameter4, vtkm::internal::IndexTag<4>());
f(parameters.Parameter5, vtkm::internal::IndexTag<5>());
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Functor,
typename R,
typename P1,
typename P2,
typename P3,
typename P4,
typename P5>
VTKM_EXEC_EXPORT
void DoForEachExec(
const Functor &f,
ParameterContainer<R(P1,P2,P3,P4,P5)> &parameters)
{
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
f(parameters.Parameter1, vtkm::internal::IndexTag<1>());
f(parameters.Parameter2, vtkm::internal::IndexTag<2>());
f(parameters.Parameter3, vtkm::internal::IndexTag<3>());
f(parameters.Parameter4, vtkm::internal::IndexTag<4>());
f(parameters.Parameter5, vtkm::internal::IndexTag<5>());
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Functor,
typename R,
typename P1,
typename P2,
typename P3,
typename P4,
typename P5,
typename P6>
VTKM_CONT_EXPORT
void DoForEachCont(
const Functor &f,
const ParameterContainer<R(P1,P2,P3,P4,P5,P6)> &parameters)
{
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
f(parameters.Parameter1, vtkm::internal::IndexTag<1>());
f(parameters.Parameter2, vtkm::internal::IndexTag<2>());
f(parameters.Parameter3, vtkm::internal::IndexTag<3>());
f(parameters.Parameter4, vtkm::internal::IndexTag<4>());
f(parameters.Parameter5, vtkm::internal::IndexTag<5>());
f(parameters.Parameter6, vtkm::internal::IndexTag<6>());
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Functor,
typename R,
typename P1,
typename P2,
typename P3,
typename P4,
typename P5,
typename P6>
VTKM_CONT_EXPORT
void DoForEachCont(
const Functor &f,
ParameterContainer<R(P1,P2,P3,P4,P5,P6)> &parameters)
{
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
f(parameters.Parameter1, vtkm::internal::IndexTag<1>());
f(parameters.Parameter2, vtkm::internal::IndexTag<2>());
f(parameters.Parameter3, vtkm::internal::IndexTag<3>());
f(parameters.Parameter4, vtkm::internal::IndexTag<4>());
f(parameters.Parameter5, vtkm::internal::IndexTag<5>());
f(parameters.Parameter6, vtkm::internal::IndexTag<6>());
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Functor,
typename R,
typename P1,
typename P2,
typename P3,
typename P4,
typename P5,
typename P6>
VTKM_EXEC_EXPORT
void DoForEachExec(
const Functor &f,
const ParameterContainer<R(P1,P2,P3,P4,P5,P6)> &parameters)
{
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
f(parameters.Parameter1, vtkm::internal::IndexTag<1>());
f(parameters.Parameter2, vtkm::internal::IndexTag<2>());
f(parameters.Parameter3, vtkm::internal::IndexTag<3>());
f(parameters.Parameter4, vtkm::internal::IndexTag<4>());
f(parameters.Parameter5, vtkm::internal::IndexTag<5>());
f(parameters.Parameter6, vtkm::internal::IndexTag<6>());
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Functor,
typename R,
typename P1,
typename P2,
typename P3,
typename P4,
typename P5,
typename P6>
VTKM_EXEC_EXPORT
void DoForEachExec(
const Functor &f,
ParameterContainer<R(P1,P2,P3,P4,P5,P6)> &parameters)
{
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
f(parameters.Parameter1, vtkm::internal::IndexTag<1>());
f(parameters.Parameter2, vtkm::internal::IndexTag<2>());
f(parameters.Parameter3, vtkm::internal::IndexTag<3>());
f(parameters.Parameter4, vtkm::internal::IndexTag<4>());
f(parameters.Parameter5, vtkm::internal::IndexTag<5>());
f(parameters.Parameter6, vtkm::internal::IndexTag<6>());
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Functor,
typename R,
typename P1,
typename P2,
typename P3,
typename P4,
typename P5,
typename P6,
typename P7>
VTKM_CONT_EXPORT
void DoForEachCont(
const Functor &f,
const ParameterContainer<R(P1,P2,P3,P4,P5,P6,P7)> &parameters)
{
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
f(parameters.Parameter1, vtkm::internal::IndexTag<1>());
f(parameters.Parameter2, vtkm::internal::IndexTag<2>());
f(parameters.Parameter3, vtkm::internal::IndexTag<3>());
f(parameters.Parameter4, vtkm::internal::IndexTag<4>());
f(parameters.Parameter5, vtkm::internal::IndexTag<5>());
f(parameters.Parameter6, vtkm::internal::IndexTag<6>());
f(parameters.Parameter7, vtkm::internal::IndexTag<7>());
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Functor,
typename R,
typename P1,
typename P2,
typename P3,
typename P4,
typename P5,
typename P6,
typename P7>
VTKM_CONT_EXPORT
void DoForEachCont(
const Functor &f,
ParameterContainer<R(P1,P2,P3,P4,P5,P6,P7)> &parameters)
{
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
f(parameters.Parameter1, vtkm::internal::IndexTag<1>());
f(parameters.Parameter2, vtkm::internal::IndexTag<2>());
f(parameters.Parameter3, vtkm::internal::IndexTag<3>());
f(parameters.Parameter4, vtkm::internal::IndexTag<4>());
f(parameters.Parameter5, vtkm::internal::IndexTag<5>());
f(parameters.Parameter6, vtkm::internal::IndexTag<6>());
f(parameters.Parameter7, vtkm::internal::IndexTag<7>());
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Functor,
typename R,
typename P1,
typename P2,
typename P3,
typename P4,
typename P5,
typename P6,
typename P7>
VTKM_EXEC_EXPORT
void DoForEachExec(
const Functor &f,
const ParameterContainer<R(P1,P2,P3,P4,P5,P6,P7)> &parameters)
{
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
f(parameters.Parameter1, vtkm::internal::IndexTag<1>());
f(parameters.Parameter2, vtkm::internal::IndexTag<2>());
f(parameters.Parameter3, vtkm::internal::IndexTag<3>());
f(parameters.Parameter4, vtkm::internal::IndexTag<4>());
f(parameters.Parameter5, vtkm::internal::IndexTag<5>());
f(parameters.Parameter6, vtkm::internal::IndexTag<6>());
f(parameters.Parameter7, vtkm::internal::IndexTag<7>());
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Functor,
typename R,
typename P1,
typename P2,
typename P3,
typename P4,
typename P5,
typename P6,
typename P7>
VTKM_EXEC_EXPORT
void DoForEachExec(
const Functor &f,
ParameterContainer<R(P1,P2,P3,P4,P5,P6,P7)> &parameters)
{
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
f(parameters.Parameter1, vtkm::internal::IndexTag<1>());
f(parameters.Parameter2, vtkm::internal::IndexTag<2>());
f(parameters.Parameter3, vtkm::internal::IndexTag<3>());
f(parameters.Parameter4, vtkm::internal::IndexTag<4>());
f(parameters.Parameter5, vtkm::internal::IndexTag<5>());
f(parameters.Parameter6, vtkm::internal::IndexTag<6>());
f(parameters.Parameter7, vtkm::internal::IndexTag<7>());
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Functor,
typename R,
typename P1,
typename P2,
typename P3,
typename P4,
typename P5,
typename P6,
typename P7,
typename P8>
VTKM_CONT_EXPORT
void DoForEachCont(
const Functor &f,
const ParameterContainer<R(P1,P2,P3,P4,P5,P6,P7,P8)> &parameters)
{
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
f(parameters.Parameter1, vtkm::internal::IndexTag<1>());
f(parameters.Parameter2, vtkm::internal::IndexTag<2>());
f(parameters.Parameter3, vtkm::internal::IndexTag<3>());
f(parameters.Parameter4, vtkm::internal::IndexTag<4>());
f(parameters.Parameter5, vtkm::internal::IndexTag<5>());
f(parameters.Parameter6, vtkm::internal::IndexTag<6>());
f(parameters.Parameter7, vtkm::internal::IndexTag<7>());
f(parameters.Parameter8, vtkm::internal::IndexTag<8>());
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Functor,
typename R,
typename P1,
typename P2,
typename P3,
typename P4,
typename P5,
typename P6,
typename P7,
typename P8>
VTKM_CONT_EXPORT
void DoForEachCont(
const Functor &f,
ParameterContainer<R(P1,P2,P3,P4,P5,P6,P7,P8)> &parameters)
{
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
f(parameters.Parameter1, vtkm::internal::IndexTag<1>());
f(parameters.Parameter2, vtkm::internal::IndexTag<2>());
f(parameters.Parameter3, vtkm::internal::IndexTag<3>());
f(parameters.Parameter4, vtkm::internal::IndexTag<4>());
f(parameters.Parameter5, vtkm::internal::IndexTag<5>());
f(parameters.Parameter6, vtkm::internal::IndexTag<6>());
f(parameters.Parameter7, vtkm::internal::IndexTag<7>());
f(parameters.Parameter8, vtkm::internal::IndexTag<8>());
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Functor,
typename R,
typename P1,
typename P2,
typename P3,
typename P4,
typename P5,
typename P6,
typename P7,
typename P8>
VTKM_EXEC_EXPORT
void DoForEachExec(
const Functor &f,
const ParameterContainer<R(P1,P2,P3,P4,P5,P6,P7,P8)> &parameters)
{
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
f(parameters.Parameter1, vtkm::internal::IndexTag<1>());
f(parameters.Parameter2, vtkm::internal::IndexTag<2>());
f(parameters.Parameter3, vtkm::internal::IndexTag<3>());
f(parameters.Parameter4, vtkm::internal::IndexTag<4>());
f(parameters.Parameter5, vtkm::internal::IndexTag<5>());
f(parameters.Parameter6, vtkm::internal::IndexTag<6>());
f(parameters.Parameter7, vtkm::internal::IndexTag<7>());
f(parameters.Parameter8, vtkm::internal::IndexTag<8>());
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Functor,
typename R,
typename P1,
typename P2,
typename P3,
typename P4,
typename P5,
typename P6,
typename P7,
typename P8>
VTKM_EXEC_EXPORT
void DoForEachExec(
const Functor &f,
ParameterContainer<R(P1,P2,P3,P4,P5,P6,P7,P8)> &parameters)
{
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
f(parameters.Parameter1, vtkm::internal::IndexTag<1>());
f(parameters.Parameter2, vtkm::internal::IndexTag<2>());
f(parameters.Parameter3, vtkm::internal::IndexTag<3>());
f(parameters.Parameter4, vtkm::internal::IndexTag<4>());
f(parameters.Parameter5, vtkm::internal::IndexTag<5>());
f(parameters.Parameter6, vtkm::internal::IndexTag<6>());
f(parameters.Parameter7, vtkm::internal::IndexTag<7>());
f(parameters.Parameter8, vtkm::internal::IndexTag<8>());
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Functor,
typename R,
typename P1,
typename P2,
typename P3,
typename P4,
typename P5,
typename P6,
typename P7,
typename P8,
typename P9>
VTKM_CONT_EXPORT
void DoForEachCont(
const Functor &f,
const ParameterContainer<R(P1,P2,P3,P4,P5,P6,P7,P8,P9)> &parameters)
{
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
f(parameters.Parameter1, vtkm::internal::IndexTag<1>());
f(parameters.Parameter2, vtkm::internal::IndexTag<2>());
f(parameters.Parameter3, vtkm::internal::IndexTag<3>());
f(parameters.Parameter4, vtkm::internal::IndexTag<4>());
f(parameters.Parameter5, vtkm::internal::IndexTag<5>());
f(parameters.Parameter6, vtkm::internal::IndexTag<6>());
f(parameters.Parameter7, vtkm::internal::IndexTag<7>());
f(parameters.Parameter8, vtkm::internal::IndexTag<8>());
f(parameters.Parameter9, vtkm::internal::IndexTag<9>());
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Functor,
typename R,
typename P1,
typename P2,
typename P3,
typename P4,
typename P5,
typename P6,
typename P7,
typename P8,
typename P9>
VTKM_CONT_EXPORT
void DoForEachCont(
const Functor &f,
ParameterContainer<R(P1,P2,P3,P4,P5,P6,P7,P8,P9)> &parameters)
{
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
f(parameters.Parameter1, vtkm::internal::IndexTag<1>());
f(parameters.Parameter2, vtkm::internal::IndexTag<2>());
f(parameters.Parameter3, vtkm::internal::IndexTag<3>());
f(parameters.Parameter4, vtkm::internal::IndexTag<4>());
f(parameters.Parameter5, vtkm::internal::IndexTag<5>());
f(parameters.Parameter6, vtkm::internal::IndexTag<6>());
f(parameters.Parameter7, vtkm::internal::IndexTag<7>());
f(parameters.Parameter8, vtkm::internal::IndexTag<8>());
f(parameters.Parameter9, vtkm::internal::IndexTag<9>());
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Functor,
typename R,
typename P1,
typename P2,
typename P3,
typename P4,
typename P5,
typename P6,
typename P7,
typename P8,
typename P9>
VTKM_EXEC_EXPORT
void DoForEachExec(
const Functor &f,
const ParameterContainer<R(P1,P2,P3,P4,P5,P6,P7,P8,P9)> &parameters)
{
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
f(parameters.Parameter1, vtkm::internal::IndexTag<1>());
f(parameters.Parameter2, vtkm::internal::IndexTag<2>());
f(parameters.Parameter3, vtkm::internal::IndexTag<3>());
f(parameters.Parameter4, vtkm::internal::IndexTag<4>());
f(parameters.Parameter5, vtkm::internal::IndexTag<5>());
f(parameters.Parameter6, vtkm::internal::IndexTag<6>());
f(parameters.Parameter7, vtkm::internal::IndexTag<7>());
f(parameters.Parameter8, vtkm::internal::IndexTag<8>());
f(parameters.Parameter9, vtkm::internal::IndexTag<9>());
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
}
FunctionInterface suppresses warnings on calling host function from host/device
2015-09-21 19:26:28 +00:00
VTKM_SUPPRESS_EXEC_WARNINGS
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
template<typename Functor,
typename R,
typename P1,
typename P2,
typename P3,
typename P4,
typename P5,
typename P6,
typename P7,
typename P8,
typename P9>
VTKM_EXEC_EXPORT
void DoForEachExec(
const Functor &f,
ParameterContainer<R(P1,P2,P3,P4,P5,P6,P7,P8,P9)> &parameters)
{
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
f(parameters.Parameter1, vtkm::internal::IndexTag<1>());
f(parameters.Parameter2, vtkm::internal::IndexTag<2>());
f(parameters.Parameter3, vtkm::internal::IndexTag<3>());
f(parameters.Parameter4, vtkm::internal::IndexTag<4>());
f(parameters.Parameter5, vtkm::internal::IndexTag<5>());
f(parameters.Parameter6, vtkm::internal::IndexTag<6>());
f(parameters.Parameter7, vtkm::internal::IndexTag<7>());
f(parameters.Parameter8, vtkm::internal::IndexTag<8>());
f(parameters.Parameter9, vtkm::internal::IndexTag<9>());
Replace Boost preprocessor iteration with macro expansion tool This commit removes the usage of the boost preprocessor library to iteratively generate templates with a variable number of parameters. It is replaced with a template that is expanded by running it through the pyexpander macro processing tool (http://pyexpander.sourceforge.net). One reason for this change is to make the code easier to read. In particular, it is difficult to understand compiler errors when they occur deep within an iterating macro. Another reason for this change is that the Intel compiler currently has a bug that breaks with the boost preprocessor library. One issue with this approach is that the macro expansion is not part of the build process. Although open, pyexpander is not a tool most developers will have readily installed on their system. Thus, if you want to make changes to any of the macro code, you have to make sure pyexpander is installed, then make changes to the input files, then manually run pyexpander from the command line.
2014-06-25 22:03:44 +00:00
}
} // namespace detail
}
} // namespace vtkm::internal
Fix wrapper macros around FunctionInterface header files The header wrapper macros in all the FunctionInterface header files declared the function interface to be in the cont package, which is wrong.
2014-10-08 16:07:08 +00:00
#endif //vtk_m_internal_FunctionInterfaceDetailPre_h
Reference in New Issue Copy Permalink