Shuenhoy/vtk-m
1
0
Fork 0
mirror of https://gitlab.kitware.com/vtk/vtk-m synced 2024-09-16 17:22:55 +00:00
Code Issues 2 Actions Packages Projects Releases Wiki Activity
e9898cc5cf
vtk-m/vtkm/exec/internal/testing/UnitTestWorkletInvokeFunctor.cxx

360 lines
12 KiB
C++
Raw Normal View History

Add basic dispatcher functionality. These changes support the implementation of DispatcherBase. This class provides the basic functionality for calling an Invoke method in the control environment, transferring data to the execution environment, scheduling threads in the execution environment, pulling data for each calling of the worklet method, and actually calling the worklet.
2014-10-21 16:51:07 +00:00
//============================================================================
// Copyright (c) Kitware, Inc.
// All rights reserved.
// See LICENSE.txt for details.
// This software is distributed WITHOUT ANY WARRANTY; without even
// the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
// PURPOSE. See the above copyright notice for more information.
//
// Copyright 2014 Sandia Corporation.
// Copyright 2014 UT-Battelle, LLC.
The Copyright statement now has all the periods in the correct location.
2015-05-21 12:09:22 +00:00
// Copyright 2014 Los Alamos National Security.
Add basic dispatcher functionality. These changes support the implementation of DispatcherBase. This class provides the basic functionality for calling an Invoke method in the control environment, transferring data to the execution environment, scheduling threads in the execution environment, pulling data for each calling of the worklet method, and actually calling the worklet.
2014-10-21 16:51:07 +00:00
//
// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
// the U.S. Government retains certain rights in this software.
//
// Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National
// Laboratory (LANL), the U.S. Government retains certain rights in
// this software.
//============================================================================
#include <vtkm/exec/internal/WorkletInvokeFunctor.h>
#include <vtkm/exec/arg/BasicArg.h>
Change Fetches to use ThreadIndices instead of Invocation. Previously, all Fetch objects received an Invocation object in their Load and Store methods. The point of this was that it allowed the Fetch to get data from any of the execution objects. However, every Fetch either just got data directly from its associated execution object or else used a secondary execution object (the input domain) to get indices into their own execution object. This left two potential areas for improvement. First, pulling data out of the Invocation object was unnecessarily complicated. It would be much nicer to get data directly from the associated execution object. Second, when getting index information from the input domain, it was often the case that extra computations were necessary (particularly on structured cell sets). There was no way to share the index information among Fetches, and therefore the computations were replicated. This change removes the Invocation from the Fetch Load and Store. Instead, it passes the associated execution object and a new object type called the ThreadIndices. The ThreadIndices are customized for the input domain and therefore have all the information needed for a redirected lookup. It is also a thread-local object so it can cache computed indices and save on computation time.
2015-10-07 18:14:00 +00:00
#include <vtkm/exec/arg/ThreadIndicesBasic.h>
Add basic dispatcher functionality. These changes support the implementation of DispatcherBase. This class provides the basic functionality for calling an Invoke method in the control environment, transferring data to the execution environment, scheduling threads in the execution environment, pulling data for each calling of the worklet method, and actually calling the worklet.
2014-10-21 16:51:07 +00:00
Declare new VTKM_STATIC_ASSERT This is to be used in place of BOOST_STATIC_ASSERT so that we can control its implementation. The implementation is designed to fix the issue where the latest XCode clang compiler gives a warning about a unused typedefs when the boost static assert is used within a function. (This warning also happens when using the C++11 static_assert keyword.) You can suppress this warning with _Pragma commands, but _Pragma commands inside a block is not supported in GCC. The implementation of VTKM_STATIC_ASSERT handles all current cases.
2015-09-17 19:45:35 +00:00
#include <vtkm/StaticAssert.h>
Add basic dispatcher functionality. These changes support the implementation of DispatcherBase. This class provides the basic functionality for calling an Invoke method in the control environment, transferring data to the execution environment, scheduling threads in the execution environment, pulling data for each calling of the worklet method, and actually calling the worklet.
2014-10-21 16:51:07 +00:00
#include <vtkm/internal/FunctionInterface.h>
Change Fetches to use ThreadIndices instead of Invocation. Previously, all Fetch objects received an Invocation object in their Load and Store methods. The point of this was that it allowed the Fetch to get data from any of the execution objects. However, every Fetch either just got data directly from its associated execution object or else used a secondary execution object (the input domain) to get indices into their own execution object. This left two potential areas for improvement. First, pulling data out of the Invocation object was unnecessarily complicated. It would be much nicer to get data directly from the associated execution object. Second, when getting index information from the input domain, it was often the case that extra computations were necessary (particularly on structured cell sets). There was no way to share the index information among Fetches, and therefore the computations were replicated. This change removes the Invocation from the Fetch Load and Store. Instead, it passes the associated execution object and a new object type called the ThreadIndices. The ThreadIndices are customized for the input domain and therefore have all the information needed for a redirected lookup. It is also a thread-local object so it can cache computed indices and save on computation time.
2015-10-07 18:14:00 +00:00
#include <vtkm/internal/Invocation.h>
Add basic dispatcher functionality. These changes support the implementation of DispatcherBase. This class provides the basic functionality for calling an Invoke method in the control environment, transferring data to the execution environment, scheduling threads in the execution environment, pulling data for each calling of the worklet method, and actually calling the worklet.
2014-10-21 16:51:07 +00:00
#include <vtkm/testing/Testing.h>
namespace {
struct TestExecObject
{
Remove exports for header-only functions/methods Change the VTKM_CONT_EXPORT to VTKM_CONT. (Likewise for EXEC and EXEC_CONT.) Remove the inline from these macros so that they can be applied to everything, including implementations in a library. Because inline is not declared in these modifies, you have to add the keyword to functions and methods where the implementation is not inlined in the class.
2016-10-19 22:42:58 +00:00
VTKM_EXEC_CONT
Add basic dispatcher functionality. These changes support the implementation of DispatcherBase. This class provides the basic functionality for calling an Invoke method in the control environment, transferring data to the execution environment, scheduling threads in the execution environment, pulling data for each calling of the worklet method, and actually calling the worklet.
2014-10-21 16:51:07 +00:00
TestExecObject() : Value(NULL) { }
Remove exports for header-only functions/methods Change the VTKM_CONT_EXPORT to VTKM_CONT. (Likewise for EXEC and EXEC_CONT.) Remove the inline from these macros so that they can be applied to everything, including implementations in a library. Because inline is not declared in these modifies, you have to add the keyword to functions and methods where the implementation is not inlined in the class.
2016-10-19 22:42:58 +00:00
VTKM_EXEC_CONT
Add basic dispatcher functionality. These changes support the implementation of DispatcherBase. This class provides the basic functionality for calling an Invoke method in the control environment, transferring data to the execution environment, scheduling threads in the execution environment, pulling data for each calling of the worklet method, and actually calling the worklet.
2014-10-21 16:51:07 +00:00
TestExecObject(vtkm::Id *value) : Value(value) { }
vtkm::Id *Value;
};
Enable output to input map in fetch mechanism. This changes the interface to the ThreadIndices classes to have both input and output indices. It also adds a visit index to ThreadIndices. Also added the VisitIndex execution signature tag, which relies on this behavior.
2015-09-23 19:38:49 +00:00
struct MyOutputToInputMapPortal
{
typedef vtkm::Id ValueType;
Remove exports for header-only functions/methods Change the VTKM_CONT_EXPORT to VTKM_CONT. (Likewise for EXEC and EXEC_CONT.) Remove the inline from these macros so that they can be applied to everything, including implementations in a library. Because inline is not declared in these modifies, you have to add the keyword to functions and methods where the implementation is not inlined in the class.
2016-10-19 22:42:58 +00:00
VTKM_EXEC_CONT
Enable output to input map in fetch mechanism. This changes the interface to the ThreadIndices classes to have both input and output indices. It also adds a visit index to ThreadIndices. Also added the VisitIndex execution signature tag, which relies on this behavior.
2015-09-23 19:38:49 +00:00
vtkm::Id Get(vtkm::Id index) const { return index; }
};
struct MyVisitArrayPortal
{
typedef vtkm::IdComponent ValueType;
vtkm::IdComponent Get(vtkm::Id) const { return 1; }
};
Add basic dispatcher functionality. These changes support the implementation of DispatcherBase. This class provides the basic functionality for calling an Invoke method in the control environment, transferring data to the execution environment, scheduling threads in the execution environment, pulling data for each calling of the worklet method, and actually calling the worklet.
2014-10-21 16:51:07 +00:00
struct TestFetchTagInput { };
struct TestFetchTagOutput { };
// Missing TransportTag, but we are not testing that so we can leave it out.
struct TestControlSignatureTagInput
{
typedef TestFetchTagInput FetchTag;
};
struct TestControlSignatureTagOutput
{
typedef TestFetchTagOutput FetchTag;
};
} // anonymous namespace
namespace vtkm {
namespace exec {
namespace arg {
Change Fetches to use ThreadIndices instead of Invocation. Previously, all Fetch objects received an Invocation object in their Load and Store methods. The point of this was that it allowed the Fetch to get data from any of the execution objects. However, every Fetch either just got data directly from its associated execution object or else used a secondary execution object (the input domain) to get indices into their own execution object. This left two potential areas for improvement. First, pulling data out of the Invocation object was unnecessarily complicated. It would be much nicer to get data directly from the associated execution object. Second, when getting index information from the input domain, it was often the case that extra computations were necessary (particularly on structured cell sets). There was no way to share the index information among Fetches, and therefore the computations were replicated. This change removes the Invocation from the Fetch Load and Store. Instead, it passes the associated execution object and a new object type called the ThreadIndices. The ThreadIndices are customized for the input domain and therefore have all the information needed for a redirected lookup. It is also a thread-local object so it can cache computed indices and save on computation time.
2015-10-07 18:14:00 +00:00
template<>
struct Fetch<
TestFetchTagInput,
vtkm::exec::arg::AspectTagDefault,
vtkm::exec::arg::ThreadIndicesBasic,
TestExecObject>
Add basic dispatcher functionality. These changes support the implementation of DispatcherBase. This class provides the basic functionality for calling an Invoke method in the control environment, transferring data to the execution environment, scheduling threads in the execution environment, pulling data for each calling of the worklet method, and actually calling the worklet.
2014-10-21 16:51:07 +00:00
{
typedef vtkm::Id ValueType;
Remove exports for header-only functions/methods Change the VTKM_CONT_EXPORT to VTKM_CONT. (Likewise for EXEC and EXEC_CONT.) Remove the inline from these macros so that they can be applied to everything, including implementations in a library. Because inline is not declared in these modifies, you have to add the keyword to functions and methods where the implementation is not inlined in the class.
2016-10-19 22:42:58 +00:00
VTKM_EXEC
Change Fetches to use ThreadIndices instead of Invocation. Previously, all Fetch objects received an Invocation object in their Load and Store methods. The point of this was that it allowed the Fetch to get data from any of the execution objects. However, every Fetch either just got data directly from its associated execution object or else used a secondary execution object (the input domain) to get indices into their own execution object. This left two potential areas for improvement. First, pulling data out of the Invocation object was unnecessarily complicated. It would be much nicer to get data directly from the associated execution object. Second, when getting index information from the input domain, it was often the case that extra computations were necessary (particularly on structured cell sets). There was no way to share the index information among Fetches, and therefore the computations were replicated. This change removes the Invocation from the Fetch Load and Store. Instead, it passes the associated execution object and a new object type called the ThreadIndices. The ThreadIndices are customized for the input domain and therefore have all the information needed for a redirected lookup. It is also a thread-local object so it can cache computed indices and save on computation time.
2015-10-07 18:14:00 +00:00
ValueType Load(const vtkm::exec::arg::ThreadIndicesBasic &indices,
const TestExecObject &execObject) const {
Enable output to input map in fetch mechanism. This changes the interface to the ThreadIndices classes to have both input and output indices. It also adds a visit index to ThreadIndices. Also added the VisitIndex execution signature tag, which relies on this behavior.
2015-09-23 19:38:49 +00:00
return *execObject.Value + 10*indices.GetInputIndex();
Add basic dispatcher functionality. These changes support the implementation of DispatcherBase. This class provides the basic functionality for calling an Invoke method in the control environment, transferring data to the execution environment, scheduling threads in the execution environment, pulling data for each calling of the worklet method, and actually calling the worklet.
2014-10-21 16:51:07 +00:00
}
Remove exports for header-only functions/methods Change the VTKM_CONT_EXPORT to VTKM_CONT. (Likewise for EXEC and EXEC_CONT.) Remove the inline from these macros so that they can be applied to everything, including implementations in a library. Because inline is not declared in these modifies, you have to add the keyword to functions and methods where the implementation is not inlined in the class.
2016-10-19 22:42:58 +00:00
VTKM_EXEC
Change Fetches to use ThreadIndices instead of Invocation. Previously, all Fetch objects received an Invocation object in their Load and Store methods. The point of this was that it allowed the Fetch to get data from any of the execution objects. However, every Fetch either just got data directly from its associated execution object or else used a secondary execution object (the input domain) to get indices into their own execution object. This left two potential areas for improvement. First, pulling data out of the Invocation object was unnecessarily complicated. It would be much nicer to get data directly from the associated execution object. Second, when getting index information from the input domain, it was often the case that extra computations were necessary (particularly on structured cell sets). There was no way to share the index information among Fetches, and therefore the computations were replicated. This change removes the Invocation from the Fetch Load and Store. Instead, it passes the associated execution object and a new object type called the ThreadIndices. The ThreadIndices are customized for the input domain and therefore have all the information needed for a redirected lookup. It is also a thread-local object so it can cache computed indices and save on computation time.
2015-10-07 18:14:00 +00:00
void Store(const vtkm::exec::arg::ThreadIndicesBasic &,
const TestExecObject &,
ValueType) const {
Add basic dispatcher functionality. These changes support the implementation of DispatcherBase. This class provides the basic functionality for calling an Invoke method in the control environment, transferring data to the execution environment, scheduling threads in the execution environment, pulling data for each calling of the worklet method, and actually calling the worklet.
2014-10-21 16:51:07 +00:00
// No-op
}
};
Change Fetches to use ThreadIndices instead of Invocation. Previously, all Fetch objects received an Invocation object in their Load and Store methods. The point of this was that it allowed the Fetch to get data from any of the execution objects. However, every Fetch either just got data directly from its associated execution object or else used a secondary execution object (the input domain) to get indices into their own execution object. This left two potential areas for improvement. First, pulling data out of the Invocation object was unnecessarily complicated. It would be much nicer to get data directly from the associated execution object. Second, when getting index information from the input domain, it was often the case that extra computations were necessary (particularly on structured cell sets). There was no way to share the index information among Fetches, and therefore the computations were replicated. This change removes the Invocation from the Fetch Load and Store. Instead, it passes the associated execution object and a new object type called the ThreadIndices. The ThreadIndices are customized for the input domain and therefore have all the information needed for a redirected lookup. It is also a thread-local object so it can cache computed indices and save on computation time.
2015-10-07 18:14:00 +00:00
template<>
struct Fetch<
TestFetchTagOutput,
vtkm::exec::arg::AspectTagDefault,
vtkm::exec::arg::ThreadIndicesBasic,
TestExecObject>
Add basic dispatcher functionality. These changes support the implementation of DispatcherBase. This class provides the basic functionality for calling an Invoke method in the control environment, transferring data to the execution environment, scheduling threads in the execution environment, pulling data for each calling of the worklet method, and actually calling the worklet.
2014-10-21 16:51:07 +00:00
{
typedef vtkm::Id ValueType;
Remove exports for header-only functions/methods Change the VTKM_CONT_EXPORT to VTKM_CONT. (Likewise for EXEC and EXEC_CONT.) Remove the inline from these macros so that they can be applied to everything, including implementations in a library. Because inline is not declared in these modifies, you have to add the keyword to functions and methods where the implementation is not inlined in the class.
2016-10-19 22:42:58 +00:00
VTKM_EXEC
Change Fetches to use ThreadIndices instead of Invocation. Previously, all Fetch objects received an Invocation object in their Load and Store methods. The point of this was that it allowed the Fetch to get data from any of the execution objects. However, every Fetch either just got data directly from its associated execution object or else used a secondary execution object (the input domain) to get indices into their own execution object. This left two potential areas for improvement. First, pulling data out of the Invocation object was unnecessarily complicated. It would be much nicer to get data directly from the associated execution object. Second, when getting index information from the input domain, it was often the case that extra computations were necessary (particularly on structured cell sets). There was no way to share the index information among Fetches, and therefore the computations were replicated. This change removes the Invocation from the Fetch Load and Store. Instead, it passes the associated execution object and a new object type called the ThreadIndices. The ThreadIndices are customized for the input domain and therefore have all the information needed for a redirected lookup. It is also a thread-local object so it can cache computed indices and save on computation time.
2015-10-07 18:14:00 +00:00
ValueType Load(const vtkm::exec::arg::ThreadIndicesBasic &,
const TestExecObject &) const {
Add basic dispatcher functionality. These changes support the implementation of DispatcherBase. This class provides the basic functionality for calling an Invoke method in the control environment, transferring data to the execution environment, scheduling threads in the execution environment, pulling data for each calling of the worklet method, and actually calling the worklet.
2014-10-21 16:51:07 +00:00
// No-op
return ValueType();
}
Remove exports for header-only functions/methods Change the VTKM_CONT_EXPORT to VTKM_CONT. (Likewise for EXEC and EXEC_CONT.) Remove the inline from these macros so that they can be applied to everything, including implementations in a library. Because inline is not declared in these modifies, you have to add the keyword to functions and methods where the implementation is not inlined in the class.
2016-10-19 22:42:58 +00:00
VTKM_EXEC
Change Fetches to use ThreadIndices instead of Invocation. Previously, all Fetch objects received an Invocation object in their Load and Store methods. The point of this was that it allowed the Fetch to get data from any of the execution objects. However, every Fetch either just got data directly from its associated execution object or else used a secondary execution object (the input domain) to get indices into their own execution object. This left two potential areas for improvement. First, pulling data out of the Invocation object was unnecessarily complicated. It would be much nicer to get data directly from the associated execution object. Second, when getting index information from the input domain, it was often the case that extra computations were necessary (particularly on structured cell sets). There was no way to share the index information among Fetches, and therefore the computations were replicated. This change removes the Invocation from the Fetch Load and Store. Instead, it passes the associated execution object and a new object type called the ThreadIndices. The ThreadIndices are customized for the input domain and therefore have all the information needed for a redirected lookup. It is also a thread-local object so it can cache computed indices and save on computation time.
2015-10-07 18:14:00 +00:00
void Store(const vtkm::exec::arg::ThreadIndicesBasic &indices,
const TestExecObject &execObject,
Add basic dispatcher functionality. These changes support the implementation of DispatcherBase. This class provides the basic functionality for calling an Invoke method in the control environment, transferring data to the execution environment, scheduling threads in the execution environment, pulling data for each calling of the worklet method, and actually calling the worklet.
2014-10-21 16:51:07 +00:00
ValueType value) const {
Enable output to input map in fetch mechanism. This changes the interface to the ThreadIndices classes to have both input and output indices. It also adds a visit index to ThreadIndices. Also added the VisitIndex execution signature tag, which relies on this behavior.
2015-09-23 19:38:49 +00:00
*execObject.Value = value + 20*indices.GetOutputIndex();
Add basic dispatcher functionality. These changes support the implementation of DispatcherBase. This class provides the basic functionality for calling an Invoke method in the control environment, transferring data to the execution environment, scheduling threads in the execution environment, pulling data for each calling of the worklet method, and actually calling the worklet.
2014-10-21 16:51:07 +00:00
}
};
}
}
} // vtkm::exec::arg
namespace {
typedef void TestControlSignature(TestControlSignatureTagInput,
TestControlSignatureTagOutput);
typedef vtkm::internal::FunctionInterface<TestControlSignature>
TestControlInterface;
typedef void TestExecutionSignature1(vtkm::exec::arg::BasicArg<1>,
vtkm::exec::arg::BasicArg<2>);
typedef vtkm::internal::FunctionInterface<TestExecutionSignature1>
TestExecutionInterface1;
typedef vtkm::exec::arg::BasicArg<2> TestExecutionSignature2(
vtkm::exec::arg::BasicArg<1>);
typedef vtkm::internal::FunctionInterface<TestExecutionSignature2>
TestExecutionInterface2;
typedef vtkm::internal::FunctionInterface<void(TestExecObject, TestExecObject)>
ExecutionParameterInterface;
typedef vtkm::internal::Invocation<
ExecutionParameterInterface,
TestControlInterface,
TestExecutionInterface1,
Enable output to input map in fetch mechanism. This changes the interface to the ThreadIndices classes to have both input and output indices. It also adds a visit index to ThreadIndices. Also added the VisitIndex execution signature tag, which relies on this behavior.
2015-09-23 19:38:49 +00:00
1,
MyOutputToInputMapPortal,
MyVisitArrayPortal> InvocationType1;
Add basic dispatcher functionality. These changes support the implementation of DispatcherBase. This class provides the basic functionality for calling an Invoke method in the control environment, transferring data to the execution environment, scheduling threads in the execution environment, pulling data for each calling of the worklet method, and actually calling the worklet.
2014-10-21 16:51:07 +00:00
typedef vtkm::internal::Invocation<
ExecutionParameterInterface,
TestControlInterface,
TestExecutionInterface2,
Enable output to input map in fetch mechanism. This changes the interface to the ThreadIndices classes to have both input and output indices. It also adds a visit index to ThreadIndices. Also added the VisitIndex execution signature tag, which relies on this behavior.
2015-09-23 19:38:49 +00:00
1,
MyOutputToInputMapPortal,
MyVisitArrayPortal> InvocationType2;
Add basic dispatcher functionality. These changes support the implementation of DispatcherBase. This class provides the basic functionality for calling an Invoke method in the control environment, transferring data to the execution environment, scheduling threads in the execution environment, pulling data for each calling of the worklet method, and actually calling the worklet.
2014-10-21 16:51:07 +00:00
// Not a full worklet, but provides operators that we expect in a worklet.
struct TestWorkletProxy : vtkm::exec::FunctorBase
{
Remove exports for header-only functions/methods Change the VTKM_CONT_EXPORT to VTKM_CONT. (Likewise for EXEC and EXEC_CONT.) Remove the inline from these macros so that they can be applied to everything, including implementations in a library. Because inline is not declared in these modifies, you have to add the keyword to functions and methods where the implementation is not inlined in the class.
2016-10-19 22:42:58 +00:00
VTKM_EXEC
Add basic dispatcher functionality. These changes support the implementation of DispatcherBase. This class provides the basic functionality for calling an Invoke method in the control environment, transferring data to the execution environment, scheduling threads in the execution environment, pulling data for each calling of the worklet method, and actually calling the worklet.
2014-10-21 16:51:07 +00:00
void operator()(vtkm::Id input, vtkm::Id &output) const
{
output = input + 100;
}
Remove exports for header-only functions/methods Change the VTKM_CONT_EXPORT to VTKM_CONT. (Likewise for EXEC and EXEC_CONT.) Remove the inline from these macros so that they can be applied to everything, including implementations in a library. Because inline is not declared in these modifies, you have to add the keyword to functions and methods where the implementation is not inlined in the class.
2016-10-19 22:42:58 +00:00
VTKM_EXEC
Add basic dispatcher functionality. These changes support the implementation of DispatcherBase. This class provides the basic functionality for calling an Invoke method in the control environment, transferring data to the execution environment, scheduling threads in the execution environment, pulling data for each calling of the worklet method, and actually calling the worklet.
2014-10-21 16:51:07 +00:00
vtkm::Id operator()(vtkm::Id input) const
{
return input + 200;
}
Change Fetches to use ThreadIndices instead of Invocation. Previously, all Fetch objects received an Invocation object in their Load and Store methods. The point of this was that it allowed the Fetch to get data from any of the execution objects. However, every Fetch either just got data directly from its associated execution object or else used a secondary execution object (the input domain) to get indices into their own execution object. This left two potential areas for improvement. First, pulling data out of the Invocation object was unnecessarily complicated. It would be much nicer to get data directly from the associated execution object. Second, when getting index information from the input domain, it was often the case that extra computations were necessary (particularly on structured cell sets). There was no way to share the index information among Fetches, and therefore the computations were replicated. This change removes the Invocation from the Fetch Load and Store. Instead, it passes the associated execution object and a new object type called the ThreadIndices. The ThreadIndices are customized for the input domain and therefore have all the information needed for a redirected lookup. It is also a thread-local object so it can cache computed indices and save on computation time.
2015-10-07 18:14:00 +00:00
Adding global thread index offset to ThreadIndicesTopologyMap, eliminating warnings
2016-08-18 23:22:17 +00:00
template<typename T, typename OutToInArrayType, typename VisitArrayType,
typename InputDomainType, typename G>
Remove exports for header-only functions/methods Change the VTKM_CONT_EXPORT to VTKM_CONT. (Likewise for EXEC and EXEC_CONT.) Remove the inline from these macros so that they can be applied to everything, including implementations in a library. Because inline is not declared in these modifies, you have to add the keyword to functions and methods where the implementation is not inlined in the class.
2016-10-19 22:42:58 +00:00
VTKM_EXEC
Change Fetches to use ThreadIndices instead of Invocation. Previously, all Fetch objects received an Invocation object in their Load and Store methods. The point of this was that it allowed the Fetch to get data from any of the execution objects. However, every Fetch either just got data directly from its associated execution object or else used a secondary execution object (the input domain) to get indices into their own execution object. This left two potential areas for improvement. First, pulling data out of the Invocation object was unnecessarily complicated. It would be much nicer to get data directly from the associated execution object. Second, when getting index information from the input domain, it was often the case that extra computations were necessary (particularly on structured cell sets). There was no way to share the index information among Fetches, and therefore the computations were replicated. This change removes the Invocation from the Fetch Load and Store. Instead, it passes the associated execution object and a new object type called the ThreadIndices. The ThreadIndices are customized for the input domain and therefore have all the information needed for a redirected lookup. It is also a thread-local object so it can cache computed indices and save on computation time.
2015-10-07 18:14:00 +00:00
vtkm::exec::arg::ThreadIndicesBasic
Simplify ThreadIndicies so link time is reduced. ThreadIndicies constructor was templated on the invocation type, which created thousand's of versions of that symbol which all had the same behavior. So now remove that and move that logic into a Worklet function since it requires the invocation info.
2016-04-19 20:47:37 +00:00
GetThreadIndices(const T& threadIndex,
const OutToInArrayType& outToIn,
const VisitArrayType& visit,
Making work index return global value when streaming
2016-08-18 03:33:04 +00:00
const InputDomainType &,
Adding global thread index offset to ThreadIndicesTopologyMap, eliminating warnings
2016-08-18 23:22:17 +00:00
const G& globalThreadIndexOffset) const
Change Fetches to use ThreadIndices instead of Invocation. Previously, all Fetch objects received an Invocation object in their Load and Store methods. The point of this was that it allowed the Fetch to get data from any of the execution objects. However, every Fetch either just got data directly from its associated execution object or else used a secondary execution object (the input domain) to get indices into their own execution object. This left two potential areas for improvement. First, pulling data out of the Invocation object was unnecessarily complicated. It would be much nicer to get data directly from the associated execution object. Second, when getting index information from the input domain, it was often the case that extra computations were necessary (particularly on structured cell sets). There was no way to share the index information among Fetches, and therefore the computations were replicated. This change removes the Invocation from the Fetch Load and Store. Instead, it passes the associated execution object and a new object type called the ThreadIndices. The ThreadIndices are customized for the input domain and therefore have all the information needed for a redirected lookup. It is also a thread-local object so it can cache computed indices and save on computation time.
2015-10-07 18:14:00 +00:00
{
Simplify ThreadIndicies so link time is reduced. ThreadIndicies constructor was templated on the invocation type, which created thousand's of versions of that symbol which all had the same behavior. So now remove that and move that logic into a Worklet function since it requires the invocation info.
2016-04-19 20:47:37 +00:00
return vtkm::exec::arg::ThreadIndicesBasic(threadIndex,
outToIn.Get(threadIndex),
Adding global thread index offset to ThreadIndicesTopologyMap, eliminating warnings
2016-08-18 23:22:17 +00:00
visit.Get(threadIndex),
globalThreadIndexOffset );
Change Fetches to use ThreadIndices instead of Invocation. Previously, all Fetch objects received an Invocation object in their Load and Store methods. The point of this was that it allowed the Fetch to get data from any of the execution objects. However, every Fetch either just got data directly from its associated execution object or else used a secondary execution object (the input domain) to get indices into their own execution object. This left two potential areas for improvement. First, pulling data out of the Invocation object was unnecessarily complicated. It would be much nicer to get data directly from the associated execution object. Second, when getting index information from the input domain, it was often the case that extra computations were necessary (particularly on structured cell sets). There was no way to share the index information among Fetches, and therefore the computations were replicated. This change removes the Invocation from the Fetch Load and Store. Instead, it passes the associated execution object and a new object type called the ThreadIndices. The ThreadIndices are customized for the input domain and therefore have all the information needed for a redirected lookup. It is also a thread-local object so it can cache computed indices and save on computation time.
2015-10-07 18:14:00 +00:00
}
Add basic dispatcher functionality. These changes support the implementation of DispatcherBase. This class provides the basic functionality for calling an Invoke method in the control environment, transferring data to the execution environment, scheduling threads in the execution environment, pulling data for each calling of the worklet method, and actually calling the worklet.
2014-10-21 16:51:07 +00:00
};
#define ERROR_MESSAGE "Expected worklet error."
// Not a full worklet, but provides operators that we expect in a worklet.
struct TestWorkletErrorProxy : vtkm::exec::FunctorBase
{
Remove exports for header-only functions/methods Change the VTKM_CONT_EXPORT to VTKM_CONT. (Likewise for EXEC and EXEC_CONT.) Remove the inline from these macros so that they can be applied to everything, including implementations in a library. Because inline is not declared in these modifies, you have to add the keyword to functions and methods where the implementation is not inlined in the class.
2016-10-19 22:42:58 +00:00
VTKM_EXEC
Add basic dispatcher functionality. These changes support the implementation of DispatcherBase. This class provides the basic functionality for calling an Invoke method in the control environment, transferring data to the execution environment, scheduling threads in the execution environment, pulling data for each calling of the worklet method, and actually calling the worklet.
2014-10-21 16:51:07 +00:00
void operator()(vtkm::Id, vtkm::Id) const
{
this->RaiseError(ERROR_MESSAGE);
}
Change Fetches to use ThreadIndices instead of Invocation. Previously, all Fetch objects received an Invocation object in their Load and Store methods. The point of this was that it allowed the Fetch to get data from any of the execution objects. However, every Fetch either just got data directly from its associated execution object or else used a secondary execution object (the input domain) to get indices into their own execution object. This left two potential areas for improvement. First, pulling data out of the Invocation object was unnecessarily complicated. It would be much nicer to get data directly from the associated execution object. Second, when getting index information from the input domain, it was often the case that extra computations were necessary (particularly on structured cell sets). There was no way to share the index information among Fetches, and therefore the computations were replicated. This change removes the Invocation from the Fetch Load and Store. Instead, it passes the associated execution object and a new object type called the ThreadIndices. The ThreadIndices are customized for the input domain and therefore have all the information needed for a redirected lookup. It is also a thread-local object so it can cache computed indices and save on computation time.
2015-10-07 18:14:00 +00:00
Adding global thread index offset to ThreadIndicesTopologyMap, eliminating warnings
2016-08-18 23:22:17 +00:00
template<typename T, typename OutToInArrayType, typename VisitArrayType,
typename InputDomainType, typename G>
Remove exports for header-only functions/methods Change the VTKM_CONT_EXPORT to VTKM_CONT. (Likewise for EXEC and EXEC_CONT.) Remove the inline from these macros so that they can be applied to everything, including implementations in a library. Because inline is not declared in these modifies, you have to add the keyword to functions and methods where the implementation is not inlined in the class.
2016-10-19 22:42:58 +00:00
VTKM_EXEC
Change Fetches to use ThreadIndices instead of Invocation. Previously, all Fetch objects received an Invocation object in their Load and Store methods. The point of this was that it allowed the Fetch to get data from any of the execution objects. However, every Fetch either just got data directly from its associated execution object or else used a secondary execution object (the input domain) to get indices into their own execution object. This left two potential areas for improvement. First, pulling data out of the Invocation object was unnecessarily complicated. It would be much nicer to get data directly from the associated execution object. Second, when getting index information from the input domain, it was often the case that extra computations were necessary (particularly on structured cell sets). There was no way to share the index information among Fetches, and therefore the computations were replicated. This change removes the Invocation from the Fetch Load and Store. Instead, it passes the associated execution object and a new object type called the ThreadIndices. The ThreadIndices are customized for the input domain and therefore have all the information needed for a redirected lookup. It is also a thread-local object so it can cache computed indices and save on computation time.
2015-10-07 18:14:00 +00:00
vtkm::exec::arg::ThreadIndicesBasic
Simplify ThreadIndicies so link time is reduced. ThreadIndicies constructor was templated on the invocation type, which created thousand's of versions of that symbol which all had the same behavior. So now remove that and move that logic into a Worklet function since it requires the invocation info.
2016-04-19 20:47:37 +00:00
GetThreadIndices(const T& threadIndex,
const OutToInArrayType& outToIn,
const VisitArrayType& visit,
Making work index return global value when streaming
2016-08-18 03:33:04 +00:00
const InputDomainType &,
Adding global thread index offset to ThreadIndicesTopologyMap, eliminating warnings
2016-08-18 23:22:17 +00:00
const G& globalThreadIndexOffset) const
Change Fetches to use ThreadIndices instead of Invocation. Previously, all Fetch objects received an Invocation object in their Load and Store methods. The point of this was that it allowed the Fetch to get data from any of the execution objects. However, every Fetch either just got data directly from its associated execution object or else used a secondary execution object (the input domain) to get indices into their own execution object. This left two potential areas for improvement. First, pulling data out of the Invocation object was unnecessarily complicated. It would be much nicer to get data directly from the associated execution object. Second, when getting index information from the input domain, it was often the case that extra computations were necessary (particularly on structured cell sets). There was no way to share the index information among Fetches, and therefore the computations were replicated. This change removes the Invocation from the Fetch Load and Store. Instead, it passes the associated execution object and a new object type called the ThreadIndices. The ThreadIndices are customized for the input domain and therefore have all the information needed for a redirected lookup. It is also a thread-local object so it can cache computed indices and save on computation time.
2015-10-07 18:14:00 +00:00
{
Simplify ThreadIndicies so link time is reduced. ThreadIndicies constructor was templated on the invocation type, which created thousand's of versions of that symbol which all had the same behavior. So now remove that and move that logic into a Worklet function since it requires the invocation info.
2016-04-19 20:47:37 +00:00
return vtkm::exec::arg::ThreadIndicesBasic(threadIndex,
outToIn.Get(threadIndex),
Adding global thread index offset to ThreadIndicesTopologyMap, eliminating warnings
2016-08-18 23:22:17 +00:00
visit.Get(threadIndex),
globalThreadIndexOffset );
Change Fetches to use ThreadIndices instead of Invocation. Previously, all Fetch objects received an Invocation object in their Load and Store methods. The point of this was that it allowed the Fetch to get data from any of the execution objects. However, every Fetch either just got data directly from its associated execution object or else used a secondary execution object (the input domain) to get indices into their own execution object. This left two potential areas for improvement. First, pulling data out of the Invocation object was unnecessarily complicated. It would be much nicer to get data directly from the associated execution object. Second, when getting index information from the input domain, it was often the case that extra computations were necessary (particularly on structured cell sets). There was no way to share the index information among Fetches, and therefore the computations were replicated. This change removes the Invocation from the Fetch Load and Store. Instead, it passes the associated execution object and a new object type called the ThreadIndices. The ThreadIndices are customized for the input domain and therefore have all the information needed for a redirected lookup. It is also a thread-local object so it can cache computed indices and save on computation time.
2015-10-07 18:14:00 +00:00
}
Add basic dispatcher functionality. These changes support the implementation of DispatcherBase. This class provides the basic functionality for calling an Invoke method in the control environment, transferring data to the execution environment, scheduling threads in the execution environment, pulling data for each calling of the worklet method, and actually calling the worklet.
2014-10-21 16:51:07 +00:00
};
// Check behavior of InvocationToFetch helper class.
Switch over to c++11 type_traits.
2016-08-29 15:13:00 +00:00
VTKM_STATIC_ASSERT(( std::is_same<
Change Fetches to use ThreadIndices instead of Invocation. Previously, all Fetch objects received an Invocation object in their Load and Store methods. The point of this was that it allowed the Fetch to get data from any of the execution objects. However, every Fetch either just got data directly from its associated execution object or else used a secondary execution object (the input domain) to get indices into their own execution object. This left two potential areas for improvement. First, pulling data out of the Invocation object was unnecessarily complicated. It would be much nicer to get data directly from the associated execution object. Second, when getting index information from the input domain, it was often the case that extra computations were necessary (particularly on structured cell sets). There was no way to share the index information among Fetches, and therefore the computations were replicated. This change removes the Invocation from the Fetch Load and Store. Instead, it passes the associated execution object and a new object type called the ThreadIndices. The ThreadIndices are customized for the input domain and therefore have all the information needed for a redirected lookup. It is also a thread-local object so it can cache computed indices and save on computation time.
2015-10-07 18:14:00 +00:00
vtkm::exec::internal::detail::InvocationToFetch<vtkm::exec::arg::ThreadIndicesBasic,InvocationType1,1>::type,
vtkm::exec::arg::Fetch<TestFetchTagInput,vtkm::exec::arg::AspectTagDefault,vtkm::exec::arg::ThreadIndicesBasic,TestExecObject> >::type::value ));
Add basic dispatcher functionality. These changes support the implementation of DispatcherBase. This class provides the basic functionality for calling an Invoke method in the control environment, transferring data to the execution environment, scheduling threads in the execution environment, pulling data for each calling of the worklet method, and actually calling the worklet.
2014-10-21 16:51:07 +00:00
Switch over to c++11 type_traits.
2016-08-29 15:13:00 +00:00
VTKM_STATIC_ASSERT(( std::is_same<
Change Fetches to use ThreadIndices instead of Invocation. Previously, all Fetch objects received an Invocation object in their Load and Store methods. The point of this was that it allowed the Fetch to get data from any of the execution objects. However, every Fetch either just got data directly from its associated execution object or else used a secondary execution object (the input domain) to get indices into their own execution object. This left two potential areas for improvement. First, pulling data out of the Invocation object was unnecessarily complicated. It would be much nicer to get data directly from the associated execution object. Second, when getting index information from the input domain, it was often the case that extra computations were necessary (particularly on structured cell sets). There was no way to share the index information among Fetches, and therefore the computations were replicated. This change removes the Invocation from the Fetch Load and Store. Instead, it passes the associated execution object and a new object type called the ThreadIndices. The ThreadIndices are customized for the input domain and therefore have all the information needed for a redirected lookup. It is also a thread-local object so it can cache computed indices and save on computation time.
2015-10-07 18:14:00 +00:00
vtkm::exec::internal::detail::InvocationToFetch<vtkm::exec::arg::ThreadIndicesBasic,InvocationType1,2>::type,
vtkm::exec::arg::Fetch<TestFetchTagOutput,vtkm::exec::arg::AspectTagDefault,vtkm::exec::arg::ThreadIndicesBasic,TestExecObject> >::type::value ));
Add basic dispatcher functionality. These changes support the implementation of DispatcherBase. This class provides the basic functionality for calling an Invoke method in the control environment, transferring data to the execution environment, scheduling threads in the execution environment, pulling data for each calling of the worklet method, and actually calling the worklet.
2014-10-21 16:51:07 +00:00
Switch over to c++11 type_traits.
2016-08-29 15:13:00 +00:00
VTKM_STATIC_ASSERT(( std::is_same<
Change Fetches to use ThreadIndices instead of Invocation. Previously, all Fetch objects received an Invocation object in their Load and Store methods. The point of this was that it allowed the Fetch to get data from any of the execution objects. However, every Fetch either just got data directly from its associated execution object or else used a secondary execution object (the input domain) to get indices into their own execution object. This left two potential areas for improvement. First, pulling data out of the Invocation object was unnecessarily complicated. It would be much nicer to get data directly from the associated execution object. Second, when getting index information from the input domain, it was often the case that extra computations were necessary (particularly on structured cell sets). There was no way to share the index information among Fetches, and therefore the computations were replicated. This change removes the Invocation from the Fetch Load and Store. Instead, it passes the associated execution object and a new object type called the ThreadIndices. The ThreadIndices are customized for the input domain and therefore have all the information needed for a redirected lookup. It is also a thread-local object so it can cache computed indices and save on computation time.
2015-10-07 18:14:00 +00:00
vtkm::exec::internal::detail::InvocationToFetch<vtkm::exec::arg::ThreadIndicesBasic,InvocationType2,0>::type,
vtkm::exec::arg::Fetch<TestFetchTagOutput,vtkm::exec::arg::AspectTagDefault,vtkm::exec::arg::ThreadIndicesBasic,TestExecObject> >::type::value ));
template<typename Invocation>
void CallDoWorkletInvokeFunctor(const Invocation &invocation, vtkm::Id index)
{
vtkm::exec::internal::detail::DoWorkletInvokeFunctor(
TestWorkletProxy(),
invocation,
Simplify ThreadIndicies so link time is reduced. ThreadIndicies constructor was templated on the invocation type, which created thousand's of versions of that symbol which all had the same behavior. So now remove that and move that logic into a Worklet function since it requires the invocation info.
2016-04-19 20:47:37 +00:00
vtkm::exec::arg::ThreadIndicesBasic(index,
invocation.OutputToInputMap.Get(index),
invocation.VisitArray.Get(index) )
);
Change Fetches to use ThreadIndices instead of Invocation. Previously, all Fetch objects received an Invocation object in their Load and Store methods. The point of this was that it allowed the Fetch to get data from any of the execution objects. However, every Fetch either just got data directly from its associated execution object or else used a secondary execution object (the input domain) to get indices into their own execution object. This left two potential areas for improvement. First, pulling data out of the Invocation object was unnecessarily complicated. It would be much nicer to get data directly from the associated execution object. Second, when getting index information from the input domain, it was often the case that extra computations were necessary (particularly on structured cell sets). There was no way to share the index information among Fetches, and therefore the computations were replicated. This change removes the Invocation from the Fetch Load and Store. Instead, it passes the associated execution object and a new object type called the ThreadIndices. The ThreadIndices are customized for the input domain and therefore have all the information needed for a redirected lookup. It is also a thread-local object so it can cache computed indices and save on computation time.
2015-10-07 18:14:00 +00:00
}
Add basic dispatcher functionality. These changes support the implementation of DispatcherBase. This class provides the basic functionality for calling an Invoke method in the control environment, transferring data to the execution environment, scheduling threads in the execution environment, pulling data for each calling of the worklet method, and actually calling the worklet.
2014-10-21 16:51:07 +00:00
void TestDoWorkletInvoke()
{
std::cout << "Testing internal worklet invoke." << std::endl;
vtkm::Id inputTestValue;
vtkm::Id outputTestValue;
vtkm::internal::FunctionInterface<void(TestExecObject,TestExecObject)> execObjects =
vtkm::internal::make_FunctionInterface<void>(TestExecObject(&inputTestValue),
TestExecObject(&outputTestValue));
std::cout << " Try void return." << std::endl;
inputTestValue = 5;
Resolved all implicit conversions between unsigned int and vtkm::Id.
2015-05-25 10:50:18 +00:00
outputTestValue = static_cast<vtkm::Id>(0xDEADDEAD);
Change Fetches to use ThreadIndices instead of Invocation. Previously, all Fetch objects received an Invocation object in their Load and Store methods. The point of this was that it allowed the Fetch to get data from any of the execution objects. However, every Fetch either just got data directly from its associated execution object or else used a secondary execution object (the input domain) to get indices into their own execution object. This left two potential areas for improvement. First, pulling data out of the Invocation object was unnecessarily complicated. It would be much nicer to get data directly from the associated execution object. Second, when getting index information from the input domain, it was often the case that extra computations were necessary (particularly on structured cell sets). There was no way to share the index information among Fetches, and therefore the computations were replicated. This change removes the Invocation from the Fetch Load and Store. Instead, it passes the associated execution object and a new object type called the ThreadIndices. The ThreadIndices are customized for the input domain and therefore have all the information needed for a redirected lookup. It is also a thread-local object so it can cache computed indices and save on computation time.
2015-10-07 18:14:00 +00:00
CallDoWorkletInvokeFunctor(
Add basic dispatcher functionality. These changes support the implementation of DispatcherBase. This class provides the basic functionality for calling an Invoke method in the control environment, transferring data to the execution environment, scheduling threads in the execution environment, pulling data for each calling of the worklet method, and actually calling the worklet.
2014-10-21 16:51:07 +00:00
vtkm::internal::make_Invocation<1>(execObjects,
TestControlInterface(),
Enable output to input map in fetch mechanism. This changes the interface to the ThreadIndices classes to have both input and output indices. It also adds a visit index to ThreadIndices. Also added the VisitIndex execution signature tag, which relies on this behavior.
2015-09-23 19:38:49 +00:00
TestExecutionInterface1(),
MyOutputToInputMapPortal(),
MyVisitArrayPortal()),
Add basic dispatcher functionality. These changes support the implementation of DispatcherBase. This class provides the basic functionality for calling an Invoke method in the control environment, transferring data to the execution environment, scheduling threads in the execution environment, pulling data for each calling of the worklet method, and actually calling the worklet.
2014-10-21 16:51:07 +00:00
1);
VTKM_TEST_ASSERT(inputTestValue == 5, "Input value changed.");
VTKM_TEST_ASSERT(outputTestValue == inputTestValue + 100 + 30,
"Output value not set right.");
std::cout << " Try return value." << std::endl;
inputTestValue = 6;
Resolved all implicit conversions between unsigned int and vtkm::Id.
2015-05-25 10:50:18 +00:00
outputTestValue = static_cast<vtkm::Id>(0xDEADDEAD);
Change Fetches to use ThreadIndices instead of Invocation. Previously, all Fetch objects received an Invocation object in their Load and Store methods. The point of this was that it allowed the Fetch to get data from any of the execution objects. However, every Fetch either just got data directly from its associated execution object or else used a secondary execution object (the input domain) to get indices into their own execution object. This left two potential areas for improvement. First, pulling data out of the Invocation object was unnecessarily complicated. It would be much nicer to get data directly from the associated execution object. Second, when getting index information from the input domain, it was often the case that extra computations were necessary (particularly on structured cell sets). There was no way to share the index information among Fetches, and therefore the computations were replicated. This change removes the Invocation from the Fetch Load and Store. Instead, it passes the associated execution object and a new object type called the ThreadIndices. The ThreadIndices are customized for the input domain and therefore have all the information needed for a redirected lookup. It is also a thread-local object so it can cache computed indices and save on computation time.
2015-10-07 18:14:00 +00:00
CallDoWorkletInvokeFunctor(
Add basic dispatcher functionality. These changes support the implementation of DispatcherBase. This class provides the basic functionality for calling an Invoke method in the control environment, transferring data to the execution environment, scheduling threads in the execution environment, pulling data for each calling of the worklet method, and actually calling the worklet.
2014-10-21 16:51:07 +00:00
vtkm::internal::make_Invocation<1>(execObjects,
TestControlInterface(),
Enable output to input map in fetch mechanism. This changes the interface to the ThreadIndices classes to have both input and output indices. It also adds a visit index to ThreadIndices. Also added the VisitIndex execution signature tag, which relies on this behavior.
2015-09-23 19:38:49 +00:00
TestExecutionInterface2(),
MyOutputToInputMapPortal(),
MyVisitArrayPortal()),
Add basic dispatcher functionality. These changes support the implementation of DispatcherBase. This class provides the basic functionality for calling an Invoke method in the control environment, transferring data to the execution environment, scheduling threads in the execution environment, pulling data for each calling of the worklet method, and actually calling the worklet.
2014-10-21 16:51:07 +00:00
2);
VTKM_TEST_ASSERT(inputTestValue == 6, "Input value changed.");
VTKM_TEST_ASSERT(outputTestValue == inputTestValue + 200 + 30*2,
"Output value not set right.");
}
void TestNormalFunctorInvoke()
{
std::cout << "Testing normal worklet invoke." << std::endl;
vtkm::Id inputTestValue;
vtkm::Id outputTestValue;
vtkm::internal::FunctionInterface<void(TestExecObject,TestExecObject)> execObjects =
vtkm::internal::make_FunctionInterface<void>(TestExecObject(&inputTestValue),
TestExecObject(&outputTestValue));
std::cout << " Try void return." << std::endl;
inputTestValue = 5;
Resolved all implicit conversions between unsigned int and vtkm::Id.
2015-05-25 10:50:18 +00:00
outputTestValue = static_cast<vtkm::Id>(0xDEADDEAD);
Add basic dispatcher functionality. These changes support the implementation of DispatcherBase. This class provides the basic functionality for calling an Invoke method in the control environment, transferring data to the execution environment, scheduling threads in the execution environment, pulling data for each calling of the worklet method, and actually calling the worklet.
2014-10-21 16:51:07 +00:00
typedef vtkm::exec::internal::WorkletInvokeFunctor<TestWorkletProxy,InvocationType1> WorkletInvokeFunctor1;
WorkletInvokeFunctor1 workletInvokeFunctor1 =
WorkletInvokeFunctor1(TestWorkletProxy(), InvocationType1(execObjects));
workletInvokeFunctor1(1);
VTKM_TEST_ASSERT(inputTestValue == 5, "Input value changed.");
VTKM_TEST_ASSERT(outputTestValue == inputTestValue + 100 + 30,
"Output value not set right.");
std::cout << " Try return value." << std::endl;
inputTestValue = 6;
Resolved all implicit conversions between unsigned int and vtkm::Id.
2015-05-25 10:50:18 +00:00
outputTestValue = static_cast<vtkm::Id>(0xDEADDEAD);
Add basic dispatcher functionality. These changes support the implementation of DispatcherBase. This class provides the basic functionality for calling an Invoke method in the control environment, transferring data to the execution environment, scheduling threads in the execution environment, pulling data for each calling of the worklet method, and actually calling the worklet.
2014-10-21 16:51:07 +00:00
typedef vtkm::exec::internal::WorkletInvokeFunctor<TestWorkletProxy,InvocationType2> WorkletInvokeFunctor2;
WorkletInvokeFunctor2 workletInvokeFunctor2 =
WorkletInvokeFunctor2(TestWorkletProxy(), InvocationType2(execObjects));
workletInvokeFunctor2(2);
VTKM_TEST_ASSERT(inputTestValue == 6, "Input value changed.");
VTKM_TEST_ASSERT(outputTestValue == inputTestValue + 200 + 30*2,
"Output value not set right.");
}
void TestErrorFunctorInvoke()
{
std::cout << "Testing invoke with an error raised in the worklet." << std::endl;
vtkm::Id inputTestValue = 5;
Resolved all implicit conversions between unsigned int and vtkm::Id.
2015-05-25 10:50:18 +00:00
vtkm::Id outputTestValue = static_cast<vtkm::Id>(0xDEADDEAD);
Add basic dispatcher functionality. These changes support the implementation of DispatcherBase. This class provides the basic functionality for calling an Invoke method in the control environment, transferring data to the execution environment, scheduling threads in the execution environment, pulling data for each calling of the worklet method, and actually calling the worklet.
2014-10-21 16:51:07 +00:00
vtkm::internal::FunctionInterface<void(TestExecObject,TestExecObject)> execObjects =
vtkm::internal::make_FunctionInterface<void>(TestExecObject(&inputTestValue),
TestExecObject(&outputTestValue));
typedef vtkm::exec::internal::WorkletInvokeFunctor<TestWorkletErrorProxy,InvocationType1> WorkletInvokeFunctor1;
WorkletInvokeFunctor1 workletInvokeFunctor1 =
WorkletInvokeFunctor1(TestWorkletErrorProxy(), InvocationType1(execObjects));
char message[1024];
MSVC fixes One fix is a simple (pointless) compiler warning about precision. The other fix is an error in one of the test codes that did not clear out the message string in an error message buffer like it was supposed to.
2014-10-22 16:52:35 +00:00
message[0] = '\0';
Add basic dispatcher functionality. These changes support the implementation of DispatcherBase. This class provides the basic functionality for calling an Invoke method in the control environment, transferring data to the execution environment, scheduling threads in the execution environment, pulling data for each calling of the worklet method, and actually calling the worklet.
2014-10-21 16:51:07 +00:00
vtkm::exec::internal::ErrorMessageBuffer errorMessage(message, 1024);
workletInvokeFunctor1.SetErrorMessageBuffer(errorMessage);
workletInvokeFunctor1(1);
VTKM_TEST_ASSERT(errorMessage.IsErrorRaised(), "Error not raised correctly.");
VTKM_TEST_ASSERT(message == std::string(ERROR_MESSAGE),
"Got wrong error message.");
}
void TestWorkletInvokeFunctor()
{
TestDoWorkletInvoke();
TestNormalFunctorInvoke();
TestErrorFunctorInvoke();
}
} // anonymous namespace
int UnitTestWorkletInvokeFunctor(int, char *[])
{
return vtkm::testing::Testing::Run(TestWorkletInvokeFunctor);
}
Reference in New Issue Copy Permalink