Shuenhoy/vtk-m
1
0
Fork 0
mirror of https://gitlab.kitware.com/vtk/vtk-m synced 2024-09-20 02:55:47 +00:00
Code Issues 2 Actions Packages Projects Releases Wiki Activity
d1b22046eb
vtk-m/vtkm/worklet/testing/UnitTestWorkletMapField.cxx

194 lines
6.5 KiB
C++
Raw Normal View History

Add DispatcherMapField. This is a simple version of a dispatcher, but an important one. Note that there is an issue brought up with UnitTestWorkletMapField in that there needs to be better ways to specify worklet argument types.
2014-10-21 19:10:00 +00:00
//============================================================================
// Copyright (c) Kitware, Inc.
// All rights reserved.
// See LICENSE.txt for details.
conslidate the license statement
2019-04-15 23:24:21 +00:00
//
Add DispatcherMapField. This is a simple version of a dispatcher, but an important one. Note that there is an issue brought up with UnitTestWorkletMapField in that there needs to be better ways to specify worklet argument types.
2014-10-21 19:10:00 +00:00
// This software is distributed WITHOUT ANY WARRANTY; without even
// the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
// PURPOSE. See the above copyright notice for more information.
//============================================================================
Update VTK-m source to use new ArrayCopy functionality
2017-09-25 22:54:46 +00:00
#include <vtkm/cont/ArrayCopy.h>
Correct issues compiling on OSX 10.8 with CUDA 6.5 Removed the MultiParam test as we have PointElevation which does the exact same thing.
2015-07-16 18:36:57 +00:00
#include <vtkm/cont/ArrayHandle.h>
Update vtkm/worklet to work with ArrayHandleVariant
2018-11-29 14:19:30 +00:00
Enable automatic transformation of Unknown/UncertainArrayHandle
2020-08-27 23:09:55 +00:00
#include <vtkm/cont/UncertainArrayHandle.h>
#include <vtkm/cont/UnknownArrayHandle.h>
Add DispatcherMapField. This is a simple version of a dispatcher, but an important one. Note that there is an issue brought up with UnitTestWorkletMapField in that there needs to be better ways to specify worklet argument types.
2014-10-21 19:10:00 +00:00
#include <vtkm/worklet/DispatcherMapField.h>
#include <vtkm/worklet/WorkletMapField.h>
#include <vtkm/cont/testing/Testing.h>
Correct issues compiling on OSX 10.8 with CUDA 6.5 Removed the MultiParam test as we have PointElevation which does the exact same thing.
2015-07-16 18:36:57 +00:00
class TestMapFieldWorklet : public vtkm::worklet::WorkletMapField
Add DispatcherMapField. This is a simple version of a dispatcher, but an important one. Note that there is an issue brought up with UnitTestWorkletMapField in that there needs to be better ways to specify worklet argument types.
2014-10-21 19:10:00 +00:00
{
public:
Run the update-control-signature-tags.sh script
2019-01-10 18:59:25 +00:00
using ControlSignature = void(FieldIn, FieldOut, FieldInOut);
Store return value after parameters. This allows execution signatures like using ExecutionSignature = _1(_1, ...) to work as expected.
2018-12-21 16:11:57 +00:00
using ExecutionSignature = _3(_1, _2, _3, WorkIndex);
Check value type in Invoke input arrays. Instead of just checking that a dispatcher's Invoke input is an ArrayHandle, also check that the ValueType of the ArrayHandle is compatible with the types of the worklet operator. This is done by adding a template argument to the ControlSignature tags that is a type list tag that gets passed to the type check.
2014-10-22 22:51:42 +00:00
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
template <typename T>
Store return value after parameters. This allows execution signatures like using ExecutionSignature = _1(_1, ...) to work as expected.
2018-12-21 16:11:57 +00:00
VTKM_EXEC T operator()(const T& in, T& out, T& inout, vtkm::Id workIndex) const
Check value type in Invoke input arrays. Instead of just checking that a dispatcher's Invoke input is an ArrayHandle, also check that the ValueType of the ArrayHandle is compatible with the types of the worklet operator. This is done by adding a template argument to the ControlSignature tags that is a type list tag that gets passed to the type check.
2014-10-22 22:51:42 +00:00
{
Use test_equal instead of == for comparing numbers in exec worklets. A couple of tests were failing with the Intel compiler due to imprecision in comparing floating point values. Also snuck in some minor documentation fixes in a comment for FunctionInterface.
2014-11-12 15:53:03 +00:00
if (!test_equal(in, TestValue(workIndex, T()) + T(100)))
Check value type in Invoke input arrays. Instead of just checking that a dispatcher's Invoke input is an ArrayHandle, also check that the ValueType of the ArrayHandle is compatible with the types of the worklet operator. This is done by adding a template argument to the ControlSignature tags that is a type list tag that gets passed to the type check.
2014-10-22 22:51:42 +00:00
{
this->RaiseError("Got wrong input value.");
}
Fix warnings about conversion to int8 Now that UInt8 has become part of the list of default types compiled, there have been numerous warnings that have popped up about converting ints to unsigned char. The reason for these is when you do arithmetic (+, -, *, or /) on a char or short, it is automatically upconverted to a 32-bit integer. When you then try to set that back to a smaller integer, you get a conversion warning. This change gets around this problem by explicitly telling the compiler we expect this type with static_cast. We have also talked about disabling conversion warnings, but this has not happened on all dashboards, and it is not that hard to work around the warning.
2019-03-15 16:38:15 +00:00
out = static_cast<T>(in - T(100));
Add in-place (in-out) arrays to worklets. Previously, all arrays passed to worklets were designated as either input or output. No in-place operation was permitted. This change adds the FieldInOut tag for ControlSignature in both WorkletMapField and WorkletMapTopology that allows you to read and write from the same array.
2015-08-12 18:58:53 +00:00
if (!test_equal(inout, TestValue(workIndex, T()) + T(100)))
{
this->RaiseError("Got wrong in-out value.");
}
Store return value after parameters. This allows execution signatures like using ExecutionSignature = _1(_1, ...) to work as expected.
2018-12-21 16:11:57 +00:00
// We return the new value of inout. Since _3 is both an arg and return,
// this tests that the return value is set after updating the arg values.
Fix warnings about conversion to int8 Now that UInt8 has become part of the list of default types compiled, there have been numerous warnings that have popped up about converting ints to unsigned char. The reason for these is when you do arithmetic (+, -, *, or /) on a char or short, it is automatically upconverted to a 32-bit integer. When you then try to set that back to a smaller integer, you get a conversion warning. This change gets around this problem by explicitly telling the compiler we expect this type with static_cast. We have also talked about disabling conversion warnings, but this has not happened on all dashboards, and it is not that hard to work around the warning.
2019-03-15 16:38:15 +00:00
return static_cast<T>(inout - T(100));
Check value type in Invoke input arrays. Instead of just checking that a dispatcher's Invoke input is an ArrayHandle, also check that the ValueType of the ArrayHandle is compatible with the types of the worklet operator. This is done by adding a template argument to the ControlSignature tags that is a type list tag that gets passed to the type check.
2014-10-22 22:51:42 +00:00
}
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
template <typename T1, typename T2, typename T3>
Store return value after parameters. This allows execution signatures like using ExecutionSignature = _1(_1, ...) to work as expected.
2018-12-21 16:11:57 +00:00
VTKM_EXEC T3 operator()(const T1&, const T2&, const T3&, vtkm::Id) const
Check value type in Invoke input arrays. Instead of just checking that a dispatcher's Invoke input is an ArrayHandle, also check that the ValueType of the ArrayHandle is compatible with the types of the worklet operator. This is done by adding a template argument to the ControlSignature tags that is a type list tag that gets passed to the type check.
2014-10-22 22:51:42 +00:00
{
this->RaiseError("Cannot call this worklet with different types.");
Store return value after parameters. This allows execution signatures like using ExecutionSignature = _1(_1, ...) to work as expected.
2018-12-21 16:11:57 +00:00
return vtkm::TypeTraits<T3>::ZeroInitialization();
Check value type in Invoke input arrays. Instead of just checking that a dispatcher's Invoke input is an ArrayHandle, also check that the ValueType of the ArrayHandle is compatible with the types of the worklet operator. This is done by adding a template argument to the ControlSignature tags that is a type list tag that gets passed to the type check.
2014-10-22 22:51:42 +00:00
}
};
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
namespace mapfield
{
Switch over from static const to static constexpr where possible.
2018-02-27 14:25:25 +00:00
static constexpr vtkm::Id ARRAY_SIZE = 10;
Move the MapField testing worklets to a worklet namespace. NVCC is unable to handle finding the worklets when they are in an anonymous namespace. It only looks at the the anonymous namespaces included by the files that device code uses, and misses our anon namespace. Moving to a named namespace solves these issues.
2015-01-19 19:20:26 +00:00
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
template <typename WorkletType>
Update worklet UnitTests to not try statically known invalid combinations
2015-10-26 20:37:11 +00:00
struct DoStaticTestWorklet
Add DispatcherMapField. This is a simple version of a dispatcher, but an important one. Note that there is an issue brought up with UnitTestWorkletMapField in that there needs to be better ways to specify worklet argument types.
2014-10-21 19:10:00 +00:00
{
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
template <typename T>
VTKM_CONT void operator()(T) const
Add DispatcherMapField. This is a simple version of a dispatcher, but an important one. Note that there is an issue brought up with UnitTestWorkletMapField in that there needs to be better ways to specify worklet argument types.
2014-10-21 19:10:00 +00:00
{
std::cout << "Set up data." << std::endl;
T inputArray[ARRAY_SIZE];
for (vtkm::Id index = 0; index < ARRAY_SIZE; index++)
{
Fix warnings about conversion to int8 Now that UInt8 has become part of the list of default types compiled, there have been numerous warnings that have popped up about converting ints to unsigned char. The reason for these is when you do arithmetic (+, -, *, or /) on a char or short, it is automatically upconverted to a 32-bit integer. When you then try to set that back to a smaller integer, you get a conversion warning. This change gets around this problem by explicitly telling the compiler we expect this type with static_cast. We have also talked about disabling conversion warnings, but this has not happened on all dashboards, and it is not that hard to work around the warning.
2019-03-15 16:38:15 +00:00
inputArray[index] = static_cast<T>(TestValue(index, T()) + T(100));
Add DispatcherMapField. This is a simple version of a dispatcher, but an important one. Note that there is an issue brought up with UnitTestWorkletMapField in that there needs to be better ways to specify worklet argument types.
2014-10-21 19:10:00 +00:00
}
Improvements to moving data into ArrayHandle We have made several improvements to adding data into an `ArrayHandle`. ## Moving data from an `std::vector` For numerous reasons, it is convenient to define data in a `std::vector` and then wrap that into an `ArrayHandle`. It is often the case that an `std::vector` is filled and then becomes unused once it is converted to an `ArrayHandle`. In this case, what we really want is to pass the data off to the `ArrayHandle` so that the `ArrayHandle` is now managing the data and not the `std::vector`. C++11 has a mechanism to do this: move semantics. You can now pass variables to functions as an "rvalue" (right-hand value). When something is passed as an rvalue, it can pull state out of that variable and move it somewhere else. `std::vector` implements this movement so that an rvalue can be moved to another `std::vector` without actually copying the data. `make_ArrayHandle` now also takes advantage of this feature to move rvalue `std::vector`s. There is a special form of `make_ArrayHandle` named `make_ArrayHandleMove` that takes an rvalue. There is also a special overload of `make_ArrayHandle` itself that handles an rvalue `vector`. (However, using the explicit move version is better if you want to make sure the data is actually moved.) ## Make `ArrayHandle` from initalizer list A common use case for using `std::vector` (particularly in our unit tests) is to quickly add an initalizer list into an `ArrayHandle`. Now you can by simply passing an initializer list to `make_ArrayHandle`. ## Deprecated `make_ArrayHandle` with default shallow copy For historical reasons, passing an `std::vector` or a pointer to `make_ArrayHandle` does a shallow copy (i.e. `CopyFlag` defaults to `Off`). Although more efficient, this mode is inherintly unsafe, and making it the default is asking for trouble. To combat this, calling `make_ArrayHandle` without a copy flag is deprecated. In this way, if you wish to do the faster but more unsafe creation of an `ArrayHandle` you should explicitly express that. This requried quite a few changes through the VTK-m source (particularly in the tests). ## Similar changes to `Field` `vtkm::cont::Field` has a `make_Field` helper function that is similar to `make_ArrayHandle`. It also features the ability to create fields from `std::vector`s and C arrays. It also likewise had the same unsafe behavior by default of not copying from the source of the arrays. That behavior has similarly been depreciated. You now have to specify a copy flag. The ability to construct a `Field` from an initializer list of values has also been added.
2020-07-16 16:32:32 +00:00
vtkm::cont::ArrayHandle<T> inputHandle =
vtkm::cont::make_ArrayHandle(inputArray, ARRAY_SIZE, vtkm::CopyFlag::On);
VTK-m now supports passing pointers when invoking worklets. The original design of invoke and the transport infrastructure relied on the implementation behavior of vtkm::cont types such as ArrayHandle that used an internal shared_ptr to managed state. This allowed passing by value instead of passing by non-const ref when needing to transfer information to the device. As VTK-m adds support for classes that use virtuals the ability to pass by base pointer type allows for us to invoke worklets using a base type without the risk of type slicing. Additional by moving over to a non-const ref Invocation we can update all transports that have 'output' to now be by ref and therefore support types that can't be copied while being 'more' correct.
2018-06-28 18:29:27 +00:00
vtkm::cont::ArrayHandle<T> outputHandle, outputHandleAsPtr;
vtkm::cont::ArrayHandle<T> inoutHandle, inoutHandleAsPtr;
Add in-place (in-out) arrays to worklets. Previously, all arrays passed to worklets were designated as either input or output. No in-place operation was permitted. This change adds the FieldInOut tag for ControlSignature in both WorkletMapField and WorkletMapTopology that allows you to read and write from the same array.
2015-08-12 18:58:53 +00:00
Merge worklet testing executables into a device dependent shared library VTK-m has been updated to replace old per device worklet testing executables with a device dependent shared library so that it's able to accept a device adapter at runtime. Meanwhile, it updates the testing infrastructure APIs. vtkm::cont::testing::Run function would call ForceDevice when needed and if users need the device adapter info at runtime, RunOnDevice function would pass the adapter into the functor. Optional Parser is bumped from 1.3 to 1.7.
2018-10-17 19:17:29 +00:00
vtkm::cont::ArrayCopy(inputHandle, inoutHandle);
vtkm::cont::ArrayCopy(inputHandle, inoutHandleAsPtr);
Add DispatcherMapField. This is a simple version of a dispatcher, but an important one. Note that there is an issue brought up with UnitTestWorkletMapField in that there needs to be better ways to specify worklet argument types.
2014-10-21 19:10:00 +00:00
VTK-m now supports passing pointers when invoking worklets. The original design of invoke and the transport infrastructure relied on the implementation behavior of vtkm::cont types such as ArrayHandle that used an internal shared_ptr to managed state. This allowed passing by value instead of passing by non-const ref when needing to transfer information to the device. As VTK-m adds support for classes that use virtuals the ability to pass by base pointer type allows for us to invoke worklets using a base type without the risk of type slicing. Additional by moving over to a non-const ref Invocation we can update all transports that have 'output' to now be by ref and therefore support types that can't be copied while being 'more' correct.
2018-06-28 18:29:27 +00:00
std::cout << "Create and run dispatchers." << std::endl;
Check value type in Invoke input arrays. Instead of just checking that a dispatcher's Invoke input is an ArrayHandle, also check that the ValueType of the ArrayHandle is compatible with the types of the worklet operator. This is done by adding a template argument to the ControlSignature tags that is a type list tag that gets passed to the type check.
2014-10-22 22:51:42 +00:00
vtkm::worklet::DispatcherMapField<WorkletType> dispatcher;
Add in-place (in-out) arrays to worklets. Previously, all arrays passed to worklets were designated as either input or output. No in-place operation was permitted. This change adds the FieldInOut tag for ControlSignature in both WorkletMapField and WorkletMapTopology that allows you to read and write from the same array.
2015-08-12 18:58:53 +00:00
dispatcher.Invoke(inputHandle, outputHandle, inoutHandle);
VTK-m now supports passing pointers when invoking worklets. The original design of invoke and the transport infrastructure relied on the implementation behavior of vtkm::cont types such as ArrayHandle that used an internal shared_ptr to managed state. This allowed passing by value instead of passing by non-const ref when needing to transfer information to the device. As VTK-m adds support for classes that use virtuals the ability to pass by base pointer type allows for us to invoke worklets using a base type without the risk of type slicing. Additional by moving over to a non-const ref Invocation we can update all transports that have 'output' to now be by ref and therefore support types that can't be copied while being 'more' correct.
2018-06-28 18:29:27 +00:00
dispatcher.Invoke(&inputHandle, &outputHandleAsPtr, &inoutHandleAsPtr);
Add DispatcherMapField. This is a simple version of a dispatcher, but an important one. Note that there is an issue brought up with UnitTestWorkletMapField in that there needs to be better ways to specify worklet argument types.
2014-10-21 19:10:00 +00:00
VTK-m now supports passing pointers when invoking worklets. The original design of invoke and the transport infrastructure relied on the implementation behavior of vtkm::cont types such as ArrayHandle that used an internal shared_ptr to managed state. This allowed passing by value instead of passing by non-const ref when needing to transfer information to the device. As VTK-m adds support for classes that use virtuals the ability to pass by base pointer type allows for us to invoke worklets using a base type without the risk of type slicing. Additional by moving over to a non-const ref Invocation we can update all transports that have 'output' to now be by ref and therefore support types that can't be copied while being 'more' correct.
2018-06-28 18:29:27 +00:00
std::cout << "Check results." << std::endl;
Use new ways to get array portal in control environment Also fix deadlocks that occur when portals are not destroyed in time.
2020-01-28 19:14:32 +00:00
CheckPortal(outputHandle.ReadPortal());
CheckPortal(inoutHandle.ReadPortal());
CheckPortal(outputHandleAsPtr.ReadPortal());
CheckPortal(inoutHandleAsPtr.ReadPortal());
Test that the array transports check the size of input arrays
2016-12-20 00:30:41 +00:00
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
std::cout << "Try to invoke with an input array of the wrong size." << std::endl;
Deprecate ArrayHandle::Shrink This method has been subsumed by Allocate with vtkm::CopyFlag::On.
2021-01-28 21:59:40 +00:00
inputHandle.Allocate(ARRAY_SIZE / 2, vtkm::CopyFlag::On);
Test that the array transports check the size of input arrays
2016-12-20 00:30:41 +00:00
bool exceptionThrown = false;
try
{
dispatcher.Invoke(inputHandle, outputHandle, inoutHandle);
}
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
catch (vtkm::cont::ErrorBadValue& error)
Test that the array transports check the size of input arrays
2016-12-20 00:30:41 +00:00
{
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
std::cout << " Caught expected error: " << error.GetMessage() << std::endl;
Test that the array transports check the size of input arrays
2016-12-20 00:30:41 +00:00
exceptionThrown = true;
}
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
VTKM_TEST_ASSERT(exceptionThrown, "Dispatcher did not throw expected exception.");
Update worklet UnitTests to not try statically known invalid combinations
2015-10-26 20:37:11 +00:00
}
};
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
template <typename WorkletType>
Update vtkm/worklet to work with ArrayHandleVariant
2018-11-29 14:19:30 +00:00
struct DoVariantTestWorklet
Update worklet UnitTests to not try statically known invalid combinations
2015-10-26 20:37:11 +00:00
{
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
template <typename T>
VTKM_CONT void operator()(T) const
Update worklet UnitTests to not try statically known invalid combinations
2015-10-26 20:37:11 +00:00
{
std::cout << "Set up data." << std::endl;
T inputArray[ARRAY_SIZE];
for (vtkm::Id index = 0; index < ARRAY_SIZE; index++)
{
Fix warnings about conversion to int8 Now that UInt8 has become part of the list of default types compiled, there have been numerous warnings that have popped up about converting ints to unsigned char. The reason for these is when you do arithmetic (+, -, *, or /) on a char or short, it is automatically upconverted to a 32-bit integer. When you then try to set that back to a smaller integer, you get a conversion warning. This change gets around this problem by explicitly telling the compiler we expect this type with static_cast. We have also talked about disabling conversion warnings, but this has not happened on all dashboards, and it is not that hard to work around the warning.
2019-03-15 16:38:15 +00:00
inputArray[index] = static_cast<T>(TestValue(index, T()) + T(100));
Update worklet UnitTests to not try statically known invalid combinations
2015-10-26 20:37:11 +00:00
}
Improvements to moving data into ArrayHandle We have made several improvements to adding data into an `ArrayHandle`. ## Moving data from an `std::vector` For numerous reasons, it is convenient to define data in a `std::vector` and then wrap that into an `ArrayHandle`. It is often the case that an `std::vector` is filled and then becomes unused once it is converted to an `ArrayHandle`. In this case, what we really want is to pass the data off to the `ArrayHandle` so that the `ArrayHandle` is now managing the data and not the `std::vector`. C++11 has a mechanism to do this: move semantics. You can now pass variables to functions as an "rvalue" (right-hand value). When something is passed as an rvalue, it can pull state out of that variable and move it somewhere else. `std::vector` implements this movement so that an rvalue can be moved to another `std::vector` without actually copying the data. `make_ArrayHandle` now also takes advantage of this feature to move rvalue `std::vector`s. There is a special form of `make_ArrayHandle` named `make_ArrayHandleMove` that takes an rvalue. There is also a special overload of `make_ArrayHandle` itself that handles an rvalue `vector`. (However, using the explicit move version is better if you want to make sure the data is actually moved.) ## Make `ArrayHandle` from initalizer list A common use case for using `std::vector` (particularly in our unit tests) is to quickly add an initalizer list into an `ArrayHandle`. Now you can by simply passing an initializer list to `make_ArrayHandle`. ## Deprecated `make_ArrayHandle` with default shallow copy For historical reasons, passing an `std::vector` or a pointer to `make_ArrayHandle` does a shallow copy (i.e. `CopyFlag` defaults to `Off`). Although more efficient, this mode is inherintly unsafe, and making it the default is asking for trouble. To combat this, calling `make_ArrayHandle` without a copy flag is deprecated. In this way, if you wish to do the faster but more unsafe creation of an `ArrayHandle` you should explicitly express that. This requried quite a few changes through the VTK-m source (particularly in the tests). ## Similar changes to `Field` `vtkm::cont::Field` has a `make_Field` helper function that is similar to `make_ArrayHandle`. It also features the ability to create fields from `std::vector`s and C arrays. It also likewise had the same unsafe behavior by default of not copying from the source of the arrays. That behavior has similarly been depreciated. You now have to specify a copy flag. The ability to construct a `Field` from an initializer list of values has also been added.
2020-07-16 16:32:32 +00:00
vtkm::cont::ArrayHandle<T> inputHandle =
vtkm::cont::make_ArrayHandle(inputArray, ARRAY_SIZE, vtkm::CopyFlag::On);
Update worklet UnitTests to not try statically known invalid combinations
2015-10-26 20:37:11 +00:00
vtkm::cont::ArrayHandle<T> outputHandle;
vtkm::cont::ArrayHandle<T> inoutHandle;
Add DispatcherMapField. This is a simple version of a dispatcher, but an important one. Note that there is an issue brought up with UnitTestWorkletMapField in that there needs to be better ways to specify worklet argument types.
2014-10-21 19:10:00 +00:00
Update worklet UnitTests to not try statically known invalid combinations
2015-10-26 20:37:11 +00:00
Enable automatic transformation of Unknown/UncertainArrayHandle
2020-08-27 23:09:55 +00:00
std::cout << "Create and run dispatcher with unknown arrays." << std::endl;
Update worklet UnitTests to not try statically known invalid combinations
2015-10-26 20:37:11 +00:00
vtkm::worklet::DispatcherMapField<WorkletType> dispatcher;
Add types appropriate for Ascent
2020-12-10 18:46:47 +00:00
using UncertainArrayType =
vtkm::cont::UncertainArrayHandle<vtkm::List<T>, VTKM_DEFAULT_STORAGE_LIST>;
UncertainArrayType inputVariant(inputHandle);
Update worklet UnitTests to not try statically known invalid combinations
2015-10-26 20:37:11 +00:00
VTK-m now supports passing pointers when invoking worklets. The original design of invoke and the transport infrastructure relied on the implementation behavior of vtkm::cont types such as ArrayHandle that used an internal shared_ptr to managed state. This allowed passing by value instead of passing by non-const ref when needing to transfer information to the device. As VTK-m adds support for classes that use virtuals the ability to pass by base pointer type allows for us to invoke worklets using a base type without the risk of type slicing. Additional by moving over to a non-const ref Invocation we can update all transports that have 'output' to now be by ref and therefore support types that can't be copied while being 'more' correct.
2018-06-28 18:29:27 +00:00
{ //Verify we can pass by value
Merge worklet testing executables into a device dependent shared library VTK-m has been updated to replace old per device worklet testing executables with a device dependent shared library so that it's able to accept a device adapter at runtime. Meanwhile, it updates the testing infrastructure APIs. vtkm::cont::testing::Run function would call ForceDevice when needed and if users need the device adapter info at runtime, RunOnDevice function would pass the adapter into the functor. Optional Parser is bumped from 1.3 to 1.7.
2018-10-17 19:17:29 +00:00
vtkm::cont::ArrayCopy(inputHandle, inoutHandle);
Enable automatic transformation of Unknown/UncertainArrayHandle
2020-08-27 23:09:55 +00:00
vtkm::cont::UnknownArrayHandle outputVariant(outputHandle);
vtkm::cont::UnknownArrayHandle inoutVariant(inoutHandle);
dispatcher.Invoke(
Add types appropriate for Ascent
2020-12-10 18:46:47 +00:00
inputVariant.template ResetTypes<vtkm::List<T>, vtkm::List<VTKM_DEFAULT_STORAGE_TAG>>(),
Enable automatic transformation of Unknown/UncertainArrayHandle
2020-08-27 23:09:55 +00:00
outputVariant.ResetTypes<vtkm::List<T>, vtkm::List<VTKM_DEFAULT_STORAGE_TAG>>(),
inoutVariant.ResetTypes<vtkm::List<T>, vtkm::List<VTKM_DEFAULT_STORAGE_TAG>>());
Use new ways to get array portal in control environment Also fix deadlocks that occur when portals are not destroyed in time.
2020-01-28 19:14:32 +00:00
CheckPortal(outputHandle.ReadPortal());
CheckPortal(inoutHandle.ReadPortal());
VTK-m now supports passing pointers when invoking worklets. The original design of invoke and the transport infrastructure relied on the implementation behavior of vtkm::cont types such as ArrayHandle that used an internal shared_ptr to managed state. This allowed passing by value instead of passing by non-const ref when needing to transfer information to the device. As VTK-m adds support for classes that use virtuals the ability to pass by base pointer type allows for us to invoke worklets using a base type without the risk of type slicing. Additional by moving over to a non-const ref Invocation we can update all transports that have 'output' to now be by ref and therefore support types that can't be copied while being 'more' correct.
2018-06-28 18:29:27 +00:00
}
Update worklet UnitTests to not try statically known invalid combinations
2015-10-26 20:37:11 +00:00
VTK-m now supports passing pointers when invoking worklets. The original design of invoke and the transport infrastructure relied on the implementation behavior of vtkm::cont types such as ArrayHandle that used an internal shared_ptr to managed state. This allowed passing by value instead of passing by non-const ref when needing to transfer information to the device. As VTK-m adds support for classes that use virtuals the ability to pass by base pointer type allows for us to invoke worklets using a base type without the risk of type slicing. Additional by moving over to a non-const ref Invocation we can update all transports that have 'output' to now be by ref and therefore support types that can't be copied while being 'more' correct.
2018-06-28 18:29:27 +00:00
{ //Verify we can pass by pointer
Add types appropriate for Ascent
2020-12-10 18:46:47 +00:00
UncertainArrayType outputVariant(outputHandle);
UncertainArrayType inoutVariant(inoutHandle);
Improve the compile time of WorkletMap* unit tests By restricting the possible variant types we can dramatically improve compile time performance.
2019-01-24 22:31:36 +00:00
vtkm::cont::ArrayCopy(inputHandle, inoutHandle);
dispatcher.Invoke(&inputVariant, outputHandle, inoutHandle);
Use new ways to get array portal in control environment Also fix deadlocks that occur when portals are not destroyed in time.
2020-01-28 19:14:32 +00:00
CheckPortal(outputHandle.ReadPortal());
CheckPortal(inoutHandle.ReadPortal());
Improve the compile time of WorkletMap* unit tests By restricting the possible variant types we can dramatically improve compile time performance.
2019-01-24 22:31:36 +00:00
vtkm::cont::ArrayCopy(inputHandle, inoutHandle);
dispatcher.Invoke(inputHandle, &outputVariant, inoutHandle);
Use new ways to get array portal in control environment Also fix deadlocks that occur when portals are not destroyed in time.
2020-01-28 19:14:32 +00:00
CheckPortal(outputHandle.ReadPortal());
CheckPortal(inoutHandle.ReadPortal());
Improve the compile time of WorkletMap* unit tests By restricting the possible variant types we can dramatically improve compile time performance.
2019-01-24 22:31:36 +00:00
vtkm::cont::ArrayCopy(inputHandle, inoutHandle);
dispatcher.Invoke(inputHandle, outputHandle, &inoutVariant);
Use new ways to get array portal in control environment Also fix deadlocks that occur when portals are not destroyed in time.
2020-01-28 19:14:32 +00:00
CheckPortal(outputHandle.ReadPortal());
CheckPortal(inoutHandle.ReadPortal());
VTK-m now supports passing pointers when invoking worklets. The original design of invoke and the transport infrastructure relied on the implementation behavior of vtkm::cont types such as ArrayHandle that used an internal shared_ptr to managed state. This allowed passing by value instead of passing by non-const ref when needing to transfer information to the device. As VTK-m adds support for classes that use virtuals the ability to pass by base pointer type allows for us to invoke worklets using a base type without the risk of type slicing. Additional by moving over to a non-const ref Invocation we can update all transports that have 'output' to now be by ref and therefore support types that can't be copied while being 'more' correct.
2018-06-28 18:29:27 +00:00
}
Add DispatcherMapField. This is a simple version of a dispatcher, but an important one. Note that there is an issue brought up with UnitTestWorkletMapField in that there needs to be better ways to specify worklet argument types.
2014-10-21 19:10:00 +00:00
}
};
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
template <typename WorkletType>
Update worklet UnitTests to not try statically known invalid combinations
2015-10-26 20:37:11 +00:00
struct DoTestWorklet
{
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
template <typename T>
VTKM_CONT void operator()(T t) const
Update worklet UnitTests to not try statically known invalid combinations
2015-10-26 20:37:11 +00:00
{
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
DoStaticTestWorklet<WorkletType> sw;
sw(t);
Update vtkm/worklet to work with ArrayHandleVariant
2018-11-29 14:19:30 +00:00
DoVariantTestWorklet<WorkletType> dw;
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
dw(t);
Update worklet UnitTests to not try statically known invalid combinations
2015-10-26 20:37:11 +00:00
}
};
Merge worklet testing executables into a device dependent shared library VTK-m has been updated to replace old per device worklet testing executables with a device dependent shared library so that it's able to accept a device adapter at runtime. Meanwhile, it updates the testing infrastructure APIs. vtkm::cont::testing::Run function would call ForceDevice when needed and if users need the device adapter info at runtime, RunOnDevice function would pass the adapter into the functor. Optional Parser is bumped from 1.3 to 1.7.
2018-10-17 19:17:29 +00:00
void TestWorkletMapField(vtkm::cont::DeviceAdapterId id)
Add DispatcherMapField. This is a simple version of a dispatcher, but an important one. Note that there is an issue brought up with UnitTestWorkletMapField in that there needs to be better ways to specify worklet argument types.
2014-10-21 19:10:00 +00:00
{
Merge worklet testing executables into a device dependent shared library VTK-m has been updated to replace old per device worklet testing executables with a device dependent shared library so that it's able to accept a device adapter at runtime. Meanwhile, it updates the testing infrastructure APIs. vtkm::cont::testing::Run function would call ForceDevice when needed and if users need the device adapter info at runtime, RunOnDevice function would pass the adapter into the functor. Optional Parser is bumped from 1.3 to 1.7.
2018-10-17 19:17:29 +00:00
std::cout << "Testing Map Field on device adapter: " << id.GetName() << std::endl;
Allow worklet tests to be built for the cuda device adapter.
2014-12-18 16:03:35 +00:00
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
vtkm::testing::Testing::TryTypes(mapfield::DoTestWorklet<TestMapFieldWorklet>(),
Update lists in TypeListTag.h A new header named TypeList.h and the type lists have been redefined in this new file. All the types have been renamed from `TypeListTag*` to `TypeList*`. TypeListTag.h has been gutted to provide deprecated versions of the old type list names. There were also some other type lists that were changed from using the old `ListTagBase` to the new `List`.
2019-12-05 17:55:57 +00:00
vtkm::TypeListCommon());
Add DispatcherMapField. This is a simple version of a dispatcher, but an important one. Note that there is an issue brought up with UnitTestWorkletMapField in that there needs to be better ways to specify worklet argument types.
2014-10-21 19:10:00 +00:00
}
Cleanup the worklet UnitTests. Mainly move everything into namespaces.
2015-06-26 19:52:59 +00:00
} // mapfield namespace
Add DispatcherMapField. This is a simple version of a dispatcher, but an important one. Note that there is an issue brought up with UnitTestWorkletMapField in that there needs to be better ways to specify worklet argument types.
2014-10-21 19:10:00 +00:00
Merge worklet testing executables into a device dependent shared library VTK-m has been updated to replace old per device worklet testing executables with a device dependent shared library so that it's able to accept a device adapter at runtime. Meanwhile, it updates the testing infrastructure APIs. vtkm::cont::testing::Run function would call ForceDevice when needed and if users need the device adapter info at runtime, RunOnDevice function would pass the adapter into the functor. Optional Parser is bumped from 1.3 to 1.7.
2018-10-17 19:17:29 +00:00
int UnitTestWorkletMapField(int argc, char* argv[])
Add DispatcherMapField. This is a simple version of a dispatcher, but an important one. Note that there is an issue brought up with UnitTestWorkletMapField in that there needs to be better ways to specify worklet argument types.
2014-10-21 19:10:00 +00:00
{
Merge worklet testing executables into a device dependent shared library VTK-m has been updated to replace old per device worklet testing executables with a device dependent shared library so that it's able to accept a device adapter at runtime. Meanwhile, it updates the testing infrastructure APIs. vtkm::cont::testing::Run function would call ForceDevice when needed and if users need the device adapter info at runtime, RunOnDevice function would pass the adapter into the functor. Optional Parser is bumped from 1.3 to 1.7.
2018-10-17 19:17:29 +00:00
return vtkm::cont::testing::Testing::RunOnDevice(mapfield::TestWorkletMapField, argc, argv);
Add DispatcherMapField. This is a simple version of a dispatcher, but an important one. Note that there is an issue brought up with UnitTestWorkletMapField in that there needs to be better ways to specify worklet argument types.
2014-10-21 19:10:00 +00:00
}
Reference in New Issue Copy Permalink