2014-10-21 19:10:00 +00:00
|
|
|
//============================================================================
|
|
|
|
// Copyright (c) Kitware, Inc.
|
|
|
|
// All rights reserved.
|
|
|
|
// See LICENSE.txt for details.
|
2019-04-15 23:24:21 +00:00
|
|
|
//
|
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.
|
|
|
|
//============================================================================
|
2017-09-25 22:54:46 +00:00
|
|
|
#include <vtkm/cont/ArrayCopy.h>
|
2015-07-16 18:36:57 +00:00
|
|
|
#include <vtkm/cont/ArrayHandle.h>
|
2018-11-29 14:19:30 +00:00
|
|
|
|
2018-12-11 13:56:08 +00:00
|
|
|
#include <vtkm/cont/VariantArrayHandle.h>
|
2014-10-21 19:10:00 +00:00
|
|
|
|
|
|
|
#include <vtkm/worklet/DispatcherMapField.h>
|
|
|
|
#include <vtkm/worklet/WorkletMapField.h>
|
|
|
|
|
|
|
|
#include <vtkm/cont/testing/Testing.h>
|
|
|
|
|
2015-07-16 18:36:57 +00:00
|
|
|
class TestMapFieldWorklet : public vtkm::worklet::WorkletMapField
|
2014-10-21 19:10:00 +00:00
|
|
|
{
|
|
|
|
public:
|
2019-01-10 18:59:25 +00:00
|
|
|
using ControlSignature = void(FieldIn, FieldOut, FieldInOut);
|
2018-12-21 16:11:57 +00:00
|
|
|
using ExecutionSignature = _3(_1, _2, _3, WorkIndex);
|
2014-10-22 22:51:42 +00:00
|
|
|
|
2017-05-18 14:29:41 +00:00
|
|
|
template <typename T>
|
2018-12-21 16:11:57 +00:00
|
|
|
VTKM_EXEC T operator()(const T& in, T& out, T& inout, vtkm::Id workIndex) const
|
2014-10-22 22:51:42 +00:00
|
|
|
{
|
2014-11-12 15:53:03 +00:00
|
|
|
if (!test_equal(in, TestValue(workIndex, T()) + T(100)))
|
2014-10-22 22:51:42 +00:00
|
|
|
{
|
|
|
|
this->RaiseError("Got wrong input value.");
|
|
|
|
}
|
2019-03-15 16:38:15 +00:00
|
|
|
out = static_cast<T>(in - T(100));
|
2015-08-12 18:58:53 +00:00
|
|
|
if (!test_equal(inout, TestValue(workIndex, T()) + T(100)))
|
|
|
|
{
|
|
|
|
this->RaiseError("Got wrong in-out value.");
|
|
|
|
}
|
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.
|
2019-03-15 16:38:15 +00:00
|
|
|
return static_cast<T>(inout - T(100));
|
2014-10-22 22:51:42 +00:00
|
|
|
}
|
|
|
|
|
2017-05-18 14:29:41 +00:00
|
|
|
template <typename T1, typename T2, typename T3>
|
2018-12-21 16:11:57 +00:00
|
|
|
VTKM_EXEC T3 operator()(const T1&, const T2&, const T3&, vtkm::Id) const
|
2014-10-22 22:51:42 +00:00
|
|
|
{
|
|
|
|
this->RaiseError("Cannot call this worklet with different types.");
|
2018-12-21 16:11:57 +00:00
|
|
|
return vtkm::TypeTraits<T3>::ZeroInitialization();
|
2014-10-22 22:51:42 +00:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2017-05-18 14:29:41 +00:00
|
|
|
namespace mapfield
|
|
|
|
{
|
2018-02-27 14:25:25 +00:00
|
|
|
static constexpr vtkm::Id ARRAY_SIZE = 10;
|
2015-01-19 19:20:26 +00:00
|
|
|
|
2017-05-18 14:29:41 +00:00
|
|
|
template <typename WorkletType>
|
2015-10-26 20:37:11 +00:00
|
|
|
struct DoStaticTestWorklet
|
2014-10-21 19:10:00 +00:00
|
|
|
{
|
2017-05-18 14:29:41 +00:00
|
|
|
template <typename T>
|
|
|
|
VTKM_CONT void operator()(T) const
|
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++)
|
|
|
|
{
|
2019-03-15 16:38:15 +00:00
|
|
|
inputArray[index] = static_cast<T>(TestValue(index, T()) + T(100));
|
2014-10-21 19:10:00 +00:00
|
|
|
}
|
|
|
|
|
2017-05-18 14:29:41 +00:00
|
|
|
vtkm::cont::ArrayHandle<T> inputHandle = vtkm::cont::make_ArrayHandle(inputArray, ARRAY_SIZE);
|
2018-06-28 18:29:27 +00:00
|
|
|
vtkm::cont::ArrayHandle<T> outputHandle, outputHandleAsPtr;
|
|
|
|
vtkm::cont::ArrayHandle<T> inoutHandle, inoutHandleAsPtr;
|
2015-08-12 18:58:53 +00:00
|
|
|
|
2018-10-17 19:17:29 +00:00
|
|
|
vtkm::cont::ArrayCopy(inputHandle, inoutHandle);
|
|
|
|
vtkm::cont::ArrayCopy(inputHandle, inoutHandleAsPtr);
|
2014-10-21 19:10:00 +00:00
|
|
|
|
2018-06-28 18:29:27 +00:00
|
|
|
std::cout << "Create and run dispatchers." << std::endl;
|
2014-10-22 22:51:42 +00:00
|
|
|
vtkm::worklet::DispatcherMapField<WorkletType> dispatcher;
|
2015-08-12 18:58:53 +00:00
|
|
|
dispatcher.Invoke(inputHandle, outputHandle, inoutHandle);
|
2018-06-28 18:29:27 +00:00
|
|
|
dispatcher.Invoke(&inputHandle, &outputHandleAsPtr, &inoutHandleAsPtr);
|
2014-10-21 19:10:00 +00:00
|
|
|
|
2018-06-28 18:29:27 +00:00
|
|
|
std::cout << "Check results." << std::endl;
|
2014-10-21 19:10:00 +00:00
|
|
|
CheckPortal(outputHandle.GetPortalConstControl());
|
2015-08-12 18:58:53 +00:00
|
|
|
CheckPortal(inoutHandle.GetPortalConstControl());
|
2018-06-28 18:29:27 +00:00
|
|
|
CheckPortal(outputHandleAsPtr.GetPortalConstControl());
|
|
|
|
CheckPortal(inoutHandleAsPtr.GetPortalConstControl());
|
2016-12-20 00:30:41 +00:00
|
|
|
|
2017-05-18 14:29:41 +00:00
|
|
|
std::cout << "Try to invoke with an input array of the wrong size." << std::endl;
|
|
|
|
inputHandle.Shrink(ARRAY_SIZE / 2);
|
2016-12-20 00:30:41 +00:00
|
|
|
bool exceptionThrown = false;
|
|
|
|
try
|
|
|
|
{
|
|
|
|
dispatcher.Invoke(inputHandle, outputHandle, inoutHandle);
|
|
|
|
}
|
2017-05-18 14:29:41 +00:00
|
|
|
catch (vtkm::cont::ErrorBadValue& error)
|
2016-12-20 00:30:41 +00:00
|
|
|
{
|
2017-05-18 14:29:41 +00:00
|
|
|
std::cout << " Caught expected error: " << error.GetMessage() << std::endl;
|
2016-12-20 00:30:41 +00:00
|
|
|
exceptionThrown = true;
|
|
|
|
}
|
2017-05-18 14:29:41 +00:00
|
|
|
VTKM_TEST_ASSERT(exceptionThrown, "Dispatcher did not throw expected exception.");
|
2015-10-26 20:37:11 +00:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2017-05-18 14:29:41 +00:00
|
|
|
template <typename WorkletType>
|
2018-11-29 14:19:30 +00:00
|
|
|
struct DoVariantTestWorklet
|
2015-10-26 20:37:11 +00:00
|
|
|
{
|
2017-05-18 14:29:41 +00:00
|
|
|
template <typename T>
|
|
|
|
VTKM_CONT void operator()(T) const
|
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++)
|
|
|
|
{
|
2019-03-15 16:38:15 +00:00
|
|
|
inputArray[index] = static_cast<T>(TestValue(index, T()) + T(100));
|
2015-10-26 20:37:11 +00:00
|
|
|
}
|
|
|
|
|
2017-05-18 14:29:41 +00:00
|
|
|
vtkm::cont::ArrayHandle<T> inputHandle = vtkm::cont::make_ArrayHandle(inputArray, ARRAY_SIZE);
|
2015-10-26 20:37:11 +00:00
|
|
|
vtkm::cont::ArrayHandle<T> outputHandle;
|
|
|
|
vtkm::cont::ArrayHandle<T> inoutHandle;
|
2014-10-21 19:10:00 +00:00
|
|
|
|
2015-10-26 20:37:11 +00:00
|
|
|
|
2018-11-29 14:19:30 +00:00
|
|
|
std::cout << "Create and run dispatcher with variant arrays." << std::endl;
|
2015-10-26 20:37:11 +00:00
|
|
|
vtkm::worklet::DispatcherMapField<WorkletType> dispatcher;
|
|
|
|
|
2018-12-11 13:56:08 +00:00
|
|
|
vtkm::cont::VariantArrayHandle inputVariant(inputHandle);
|
2015-10-26 20:37:11 +00:00
|
|
|
|
2018-06-28 18:29:27 +00:00
|
|
|
{ //Verify we can pass by value
|
2018-10-17 19:17:29 +00:00
|
|
|
vtkm::cont::ArrayCopy(inputHandle, inoutHandle);
|
2018-12-11 13:56:08 +00:00
|
|
|
vtkm::cont::VariantArrayHandle outputVariant(outputHandle);
|
|
|
|
vtkm::cont::VariantArrayHandle inoutVariant(inoutHandle);
|
2019-01-24 22:31:36 +00:00
|
|
|
dispatcher.Invoke(inputVariant.ResetTypes(vtkm::ListTagBase<T>{}),
|
|
|
|
outputVariant.ResetTypes(vtkm::ListTagBase<T>{}),
|
|
|
|
inoutVariant.ResetTypes(vtkm::ListTagBase<T>{}));
|
2018-06-28 18:29:27 +00:00
|
|
|
CheckPortal(outputHandle.GetPortalConstControl());
|
|
|
|
CheckPortal(inoutHandle.GetPortalConstControl());
|
|
|
|
}
|
2015-10-26 20:37:11 +00:00
|
|
|
|
2018-06-28 18:29:27 +00:00
|
|
|
{ //Verify we can pass by pointer
|
2018-12-11 13:56:08 +00:00
|
|
|
vtkm::cont::VariantArrayHandle outputVariant(outputHandle);
|
|
|
|
vtkm::cont::VariantArrayHandle inoutVariant(inoutHandle);
|
2019-01-24 22:31:36 +00:00
|
|
|
|
|
|
|
vtkm::cont::ArrayCopy(inputHandle, inoutHandle);
|
|
|
|
dispatcher.Invoke(&inputVariant, outputHandle, inoutHandle);
|
|
|
|
CheckPortal(outputHandle.GetPortalConstControl());
|
|
|
|
CheckPortal(inoutHandle.GetPortalConstControl());
|
|
|
|
|
|
|
|
vtkm::cont::ArrayCopy(inputHandle, inoutHandle);
|
|
|
|
dispatcher.Invoke(inputHandle, &outputVariant, inoutHandle);
|
|
|
|
CheckPortal(outputHandle.GetPortalConstControl());
|
|
|
|
CheckPortal(inoutHandle.GetPortalConstControl());
|
|
|
|
|
|
|
|
vtkm::cont::ArrayCopy(inputHandle, inoutHandle);
|
|
|
|
dispatcher.Invoke(inputHandle, outputHandle, &inoutVariant);
|
2018-06-28 18:29:27 +00:00
|
|
|
CheckPortal(outputHandle.GetPortalConstControl());
|
|
|
|
CheckPortal(inoutHandle.GetPortalConstControl());
|
|
|
|
}
|
2014-10-21 19:10:00 +00:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2017-05-18 14:29:41 +00:00
|
|
|
template <typename WorkletType>
|
2015-10-26 20:37:11 +00:00
|
|
|
struct DoTestWorklet
|
|
|
|
{
|
2017-05-18 14:29:41 +00:00
|
|
|
template <typename T>
|
|
|
|
VTKM_CONT void operator()(T t) const
|
2015-10-26 20:37:11 +00:00
|
|
|
{
|
2017-05-18 14:29:41 +00:00
|
|
|
DoStaticTestWorklet<WorkletType> sw;
|
|
|
|
sw(t);
|
2018-11-29 14:19:30 +00:00
|
|
|
DoVariantTestWorklet<WorkletType> dw;
|
2017-05-18 14:29:41 +00:00
|
|
|
dw(t);
|
2015-10-26 20:37:11 +00:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2018-10-17 19:17:29 +00:00
|
|
|
void TestWorkletMapField(vtkm::cont::DeviceAdapterId id)
|
2014-10-21 19:10:00 +00:00
|
|
|
{
|
2018-10-17 19:17:29 +00:00
|
|
|
std::cout << "Testing Map Field on device adapter: " << id.GetName() << std::endl;
|
2014-12-18 16:03:35 +00:00
|
|
|
|
2017-05-18 14:29:41 +00:00
|
|
|
vtkm::testing::Testing::TryTypes(mapfield::DoTestWorklet<TestMapFieldWorklet>(),
|
|
|
|
vtkm::TypeListTagCommon());
|
2014-10-21 19:10:00 +00:00
|
|
|
}
|
|
|
|
|
2015-06-26 19:52:59 +00:00
|
|
|
} // mapfield namespace
|
2014-10-21 19:10:00 +00:00
|
|
|
|
2018-10-17 19:17:29 +00:00
|
|
|
int UnitTestWorkletMapField(int argc, char* argv[])
|
2014-10-21 19:10:00 +00:00
|
|
|
{
|
2018-10-17 19:17:29 +00:00
|
|
|
return vtkm::cont::testing::Testing::RunOnDevice(mapfield::TestWorkletMapField, argc, argv);
|
2014-10-21 19:10:00 +00:00
|
|
|
}
|