1 //============================================================================
2 // Copyright (c) Kitware, Inc.
3 // All rights reserved.
4 // See LICENSE.txt for details.
5 // This software is distributed WITHOUT ANY WARRANTY; without even
6 // the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
7 // PURPOSE. See the above copyright notice for more information.
8 //
9 // Copyright 2015 National Technology & Engineering Solutions of Sandia, LLC (NTESS).
10 // Copyright 2015 UT-Battelle, LLC.
11 // Copyright 2015 Los Alamos National Security.
12 //
13 // Under the terms of Contract DE-NA0003525 with NTESS,
14 // the U.S. Government retains certain rights in this software.
15 //
16 // Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National
17 // Laboratory (LANL), the U.S. Government retains certain rights in
18 // this software.
19 //============================================================================
20 #include <vtkm/cont/ArrayHandle.h>
21 #include <vtkm/cont/ArrayHandleIndex.h>
22 #include <vtkm/cont/DynamicArrayHandle.h>
23
24 #include <vtkm/worklet/DispatcherMapField.h>
25 #include <vtkm/worklet/WorkletMapField.h>
26
27 #include <vtkm/cont/testing/Testing.h>
28
29 class TestWholeArrayWorklet : public vtkm::worklet::WorkletMapField
30 {
31 public:
32 using ControlSignature = void(WholeArrayIn<>, WholeArrayInOut<>, WholeArrayOut<>);
33 using ExecutionSignature = void(WorkIndex, _1, _2, _3);
34
35 template <typename InPortalType, typename InOutPortalType, typename OutPortalType>
operator ()(const vtkm::Id & index,const InPortalType & inPortal,const InOutPortalType & inOutPortal,const OutPortalType & outPortal) const36 VTKM_EXEC void operator()(const vtkm::Id& index,
37 const InPortalType& inPortal,
38 const InOutPortalType& inOutPortal,
39 const OutPortalType& outPortal) const
40 {
41 using inT = typename InPortalType::ValueType;
42 if (!test_equal(inPortal.Get(index), TestValue(index, inT())))
43 {
44 this->RaiseError("Got wrong input value.");
45 }
46
47 using inOutT = typename InOutPortalType::ValueType;
48 if (!test_equal(inOutPortal.Get(index), TestValue(index, inOutT()) + inOutT(100)))
49 {
50 this->RaiseError("Got wrong input/output value.");
51 }
52 inOutPortal.Set(index, TestValue(index, inOutT()));
53
54 using outT = typename OutPortalType::ValueType;
55 outPortal.Set(index, TestValue(index, outT()));
56 }
57 };
58
59 class TestAtomicArrayWorklet : public vtkm::worklet::WorkletMapField
60 {
61 public:
62 using ControlSignature = void(FieldIn<>, AtomicArrayInOut<>);
63 using ExecutionSignature = void(WorkIndex, _2);
64 using InputDomain = _1;
65
66 template <typename AtomicArrayType>
operator ()(const vtkm::Id & index,const AtomicArrayType & atomicArray) const67 VTKM_EXEC void operator()(const vtkm::Id& index, const AtomicArrayType& atomicArray) const
68 {
69 using ValueType = typename AtomicArrayType::ValueType;
70 atomicArray.Add(0, static_cast<ValueType>(index));
71 }
72 };
73
74 namespace map_whole_array
75 {
76
77 static constexpr vtkm::Id ARRAY_SIZE = 10;
78
79 struct DoTestWholeArrayWorklet
80 {
81 using WorkletType = TestWholeArrayWorklet;
82
83 // This just demonstrates that the WholeArray tags support dynamic arrays.
84 VTKM_CONT
CallWorkletmap_whole_array::DoTestWholeArrayWorklet85 void CallWorklet(const vtkm::cont::DynamicArrayHandle& inArray,
86 const vtkm::cont::DynamicArrayHandle& inOutArray,
87 const vtkm::cont::DynamicArrayHandle& outArray) const
88 {
89 std::cout << "Create and run dispatcher." << std::endl;
90 vtkm::worklet::DispatcherMapField<WorkletType> dispatcher;
91 dispatcher.Invoke(inArray, inOutArray, outArray);
92 }
93
94 template <typename T>
operator ()map_whole_array::DoTestWholeArrayWorklet95 VTKM_CONT void operator()(T) const
96 {
97 std::cout << "Set up data." << std::endl;
98 T inArray[ARRAY_SIZE];
99 T inOutArray[ARRAY_SIZE];
100
101 for (vtkm::Id index = 0; index < ARRAY_SIZE; index++)
102 {
103 inArray[index] = TestValue(index, T());
104 inOutArray[index] = TestValue(index, T()) + T(100);
105 }
106
107 vtkm::cont::ArrayHandle<T> inHandle = vtkm::cont::make_ArrayHandle(inArray, ARRAY_SIZE);
108 vtkm::cont::ArrayHandle<T> inOutHandle = vtkm::cont::make_ArrayHandle(inOutArray, ARRAY_SIZE);
109 vtkm::cont::ArrayHandle<T> outHandle;
110 // Output arrays must be preallocated.
111 outHandle.Allocate(ARRAY_SIZE);
112
113 this->CallWorklet(vtkm::cont::DynamicArrayHandle(inHandle),
114 vtkm::cont::DynamicArrayHandle(inOutHandle),
115 vtkm::cont::DynamicArrayHandle(outHandle));
116
117 std::cout << "Check result." << std::endl;
118 CheckPortal(inOutHandle.GetPortalConstControl());
119 CheckPortal(outHandle.GetPortalConstControl());
120 }
121 };
122
123 struct DoTestAtomicArrayWorklet
124 {
125 using WorkletType = TestAtomicArrayWorklet;
126
127 // This just demonstrates that the WholeArray tags support dynamic arrays.
128 VTKM_CONT
CallWorkletmap_whole_array::DoTestAtomicArrayWorklet129 void CallWorklet(const vtkm::cont::DynamicArrayHandle& inOutArray) const
130 {
131 std::cout << "Create and run dispatcher." << std::endl;
132 vtkm::worklet::DispatcherMapField<WorkletType> dispatcher;
133 dispatcher.Invoke(vtkm::cont::ArrayHandleIndex(ARRAY_SIZE), inOutArray);
134 }
135
136 template <typename T>
operator ()map_whole_array::DoTestAtomicArrayWorklet137 VTKM_CONT void operator()(T) const
138 {
139 std::cout << "Set up data." << std::endl;
140 T inOutValue = 0;
141
142 vtkm::cont::ArrayHandle<T> inOutHandle = vtkm::cont::make_ArrayHandle(&inOutValue, 1);
143
144 this->CallWorklet(vtkm::cont::DynamicArrayHandle(inOutHandle));
145
146 std::cout << "Check result." << std::endl;
147 T result = inOutHandle.GetPortalConstControl().Get(0);
148
149 VTKM_TEST_ASSERT(result == (ARRAY_SIZE * (ARRAY_SIZE - 1)) / 2,
150 "Got wrong summation in atomic array.");
151 }
152 };
153
TestWorkletMapFieldExecArg()154 void TestWorkletMapFieldExecArg()
155 {
156 using DeviceAdapterTraits = vtkm::cont::DeviceAdapterTraits<VTKM_DEFAULT_DEVICE_ADAPTER_TAG>;
157 std::cout << "Testing Worklet with WholeArray on device adapter: "
158 << DeviceAdapterTraits::GetName() << std::endl;
159
160 std::cout << "--- Worklet accepting all types." << std::endl;
161 vtkm::testing::Testing::TryTypes(map_whole_array::DoTestWholeArrayWorklet(),
162 vtkm::TypeListTagCommon());
163
164 std::cout << "--- Worklet accepting atomics." << std::endl;
165 vtkm::testing::Testing::TryTypes(map_whole_array::DoTestAtomicArrayWorklet(),
166 vtkm::cont::AtomicArrayTypeListTag());
167 }
168
169 } // anonymous namespace
170
UnitTestWorkletMapFieldWholeArray(int,char * [])171 int UnitTestWorkletMapFieldWholeArray(int, char* [])
172 {
173 return vtkm::cont::testing::Testing::Run(map_whole_array::TestWorkletMapFieldExecArg);
174 }
175