VTK-m  2.2
WorkletInvokeFunctorDetail.h
Go to the documentation of this file.
1 //============================================================================
2 // Copyright (c) Kitware, Inc.
3 // All rights reserved.
4 // See LICENSE.txt for details.
5 //
6 // This software is distributed WITHOUT ANY WARRANTY; without even
7 // the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
8 // PURPOSE. See the above copyright notice for more information.
9 //============================================================================
10 // **** DO NOT EDIT THIS FILE!!! ****
11 // This file is automatically generated by WorkletInvokeFunctorDetail.h.in
12 
13 // Technically speaking, we can implement this functionality with some clever
14 // use of FunctionInterface rather than using pyexpander to make variadic
15 // code. However, this code is probably more friendly to compilers. I expect
16 // it to compiler faster and optimize better.
17 
18 #ifndef vtk_m_exec_internal_WorkletInvokeFunctorDetail_h
19 #define vtk_m_exec_internal_WorkletInvokeFunctorDetail_h
20 
21 #if !defined(vtk_m_exec_internal_TaskSingular_h) && \
22  !defined(vtk_m_exec_internal_TaskTiling_h) && \
23  !defined(vtk_m_exec_cuda_internal_TaskStrided_h) && \
24  !defined(VTKM_TEST_HEADER_BUILD)
25 #error WorkletInvokeFunctorDetail.h must be included from TaskSingular.h, TaskTiling.h, TaskStrided.h
26 #endif
27 
28 #include <vtkm/internal/FunctionInterface.h>
29 #include <vtkm/internal/Invocation.h>
30 
31 #include <vtkm/exec/arg/Fetch.h>
32 #include <vtkm/exec/arg/FetchTagExecObject.h>
33 
34 #if VTKM_MAX_FUNCTION_PARAMETERS != 20
35 #error Mismatch of maximum parameters between FunctionInterfaceDatailPre.h.in and WorkletInvokeFunctorDetail.h.in
36 #endif
37 
38 
39 namespace vtkm
40 {
41 namespace exec
42 {
43 namespace internal
44 {
45 namespace detail
46 {
47 
48 struct DummyDeviceControlSignatureTag
49 {
50  using FetchTag = vtkm::exec::arg::FetchTagExecObject;
51 };
52 
56 template <typename ThreadIndicesType,
57  typename Invocation,
58  vtkm::IdComponent ExecutionParameterIndex>
59 struct InvocationToFetch
60 {
61  using ExecutionSignatureTag =
62  typename Invocation::ExecutionInterface::template ParameterType<ExecutionParameterIndex>::type;
63 
64  // Expected fields from ExecutionSignatureTag. If these do not exist in
65  // ExecutionSignatureTag, then something that is not really an execution
66  // signature tag was used in an ExecutionSignature.
67  static constexpr vtkm::IdComponent ControlParameterIndex = ExecutionSignatureTag::INDEX;
68  using AspectTag = typename ExecutionSignatureTag::AspectTag;
69 
70  // Find the fetch tag from the control signature tag pointed to by
71  // ParameterIndex. Note that ControlParameterIndex of 0 is reserved
72  // for getting the device adapter tag.
73  using ControlInterface = typename Invocation::ControlInterface;
74  using ControlSignatureTag =
75  typename std::conditional<
76  ControlParameterIndex == 0,
77  DummyDeviceControlSignatureTag,
78  typename ControlInterface::template ParameterType<ControlParameterIndex>::type>::type;
79  using FetchTag = typename ControlSignatureTag::FetchTag;
80 
81  using ExecObjectType =
82  typename std::conditional<
83  ControlParameterIndex == 0,
84  typename Invocation::DeviceAdapterTag,
85  typename Invocation::ParameterInterface::template ParameterType<ControlParameterIndex>::type>::type;
86 
87  using type = vtkm::exec::arg::Fetch<FetchTag, AspectTag, ExecObjectType>;
88 
89  VTKM_EXEC static ExecObjectType GetParameterImpl(const Invocation&, std::true_type)
90  {
91  return typename Invocation::DeviceAdapterTag();
92  }
93 
94  VTKM_EXEC static ExecObjectType GetParameterImpl(const Invocation& invocation, std::false_type)
95  {
96  return vtkm::internal::ParameterGet<ControlParameterIndex>(invocation.Parameters);
97  }
98 
99  VTKM_EXEC static ExecObjectType GetParameter(const Invocation& invocation)
100  {
101  return GetParameterImpl(invocation, std::integral_constant<bool, ControlParameterIndex == 0>());
102  }
103 };
104 
105 // clang-format off
106 
107 template <typename WorkletType,
108  typename ParameterInterface,
109  typename ControlInterface,
110  vtkm::IdComponent InputDomainIndex,
111  typename OutputToInputMapType,
112  typename VisitArrayType,
113  typename ThreadToOutputMapType,
114  typename DeviceAdapterTag,
115  typename ThreadIndicesType,
116  typename R,
117  typename P1>
118 VTKM_EXEC void DoWorkletInvokeFunctor(
119  const WorkletType& worklet,
120  const vtkm::internal::Invocation<ParameterInterface,
121  ControlInterface,
122  vtkm::internal::FunctionInterface<R(P1)>,
123  InputDomainIndex,
124  OutputToInputMapType,
125  VisitArrayType,
126  ThreadToOutputMapType,
127  DeviceAdapterTag>& invocation,
128  const ThreadIndicesType& threadIndices)
129 {
130  using Invocation = vtkm::internal::Invocation<ParameterInterface,
131  ControlInterface,
132  vtkm::internal::FunctionInterface<R(P1)>,
133  InputDomainIndex,
134  OutputToInputMapType,
135  VisitArrayType,
136  ThreadToOutputMapType,
137  DeviceAdapterTag>;
138 
139  using FetchInfo1 = InvocationToFetch<ThreadIndicesType, Invocation, 1>;
140  using FetchType1 = typename FetchInfo1::type;
141  FetchType1 fetch1;
142  auto p1 =
143  fetch1.Load(threadIndices, FetchInfo1::GetParameter(invocation));
144 
145  using FetchInfo0 = InvocationToFetch<ThreadIndicesType, Invocation, 0>;
146  using ReturnFetchType = typename FetchInfo0::type;
147  ReturnFetchType returnFetch;
148  // If you got a compile error on the following line, it probably means that
149  // the operator() of a worklet does not match the definition expected. One
150  // common problem is that the operator() method must be declared const. Check
151  // to make sure the "const" keyword is after parameters. Another common
152  // problem is that the type of one or more parameters is incompatible with
153  // the actual type that VTK-m creates in the execution environment. Make sure
154  // that the types of the worklet operator() parameters match those in the
155  // ExecutionSignature. The compiler error might help you narrow down which
156  // parameter is wrong and the types that did not match.
157  auto r = worklet(p1);
158 
159  fetch1.Store(threadIndices, FetchInfo1::GetParameter(invocation), p1);
160 
161  returnFetch.Store(threadIndices, FetchInfo0::GetParameter(invocation), r);
162 }
163 
164 template <typename WorkletType,
165  typename ParameterInterface,
166  typename ControlInterface,
167  vtkm::IdComponent InputDomainIndex,
168  typename OutputToInputMapType,
169  typename VisitArrayType,
170  typename ThreadToOutputMapType,
171  typename DeviceAdapterTag,
172  typename ThreadIndicesType,
173  typename P1>
174 VTKM_EXEC void DoWorkletInvokeFunctor(
175  const WorkletType& worklet,
176  const vtkm::internal::Invocation<ParameterInterface,
177  ControlInterface,
178  vtkm::internal::FunctionInterface<void(P1)>,
179  InputDomainIndex,
180  OutputToInputMapType,
181  VisitArrayType,
182  ThreadToOutputMapType,
183  DeviceAdapterTag>& invocation,
184  const ThreadIndicesType& threadIndices)
185 {
186  using Invocation =
187  vtkm::internal::Invocation<ParameterInterface,
188  ControlInterface,
189  vtkm::internal::FunctionInterface<void(P1)>,
190  InputDomainIndex,
191  OutputToInputMapType,
192  VisitArrayType,
193  ThreadToOutputMapType,
194  DeviceAdapterTag>;
195 
196  using FetchInfo1 = InvocationToFetch<ThreadIndicesType, Invocation, 1>;
197  using FetchType1 = typename FetchInfo1::type;
198  FetchType1 fetch1;
199  auto p1 =
200  fetch1.Load(threadIndices, FetchInfo1::GetParameter(invocation));
201 
202  // If you got a compile error on the following line, it probably means that
203  // the operator() of a worklet does not match the definition expected. One
204  // common problem is that the operator() method must be declared const. Check
205  // to make sure the "const" keyword is after parameters. Another common
206  // problem is that the type of one or more parameters is incompatible with
207  // the actual type that VTK-m creates in the execution environment. Make sure
208  // that the types of the worklet operator() parameters match those in the
209  // ExecutionSignature. The compiler error might help you narrow down which
210  // parameter is wrong and the types that did not match.
211  worklet(p1);
212 
213  fetch1.Store(threadIndices, FetchInfo1::GetParameter(invocation), p1);
214 }
215 
216 template <typename WorkletType,
217  typename ParameterInterface,
218  typename ControlInterface,
219  vtkm::IdComponent InputDomainIndex,
220  typename OutputToInputMapType,
221  typename VisitArrayType,
222  typename ThreadToOutputMapType,
223  typename DeviceAdapterTag,
224  typename ThreadIndicesType,
225  typename R,
226  typename P1,
227  typename P2>
228 VTKM_EXEC void DoWorkletInvokeFunctor(
229  const WorkletType& worklet,
230  const vtkm::internal::Invocation<ParameterInterface,
231  ControlInterface,
232  vtkm::internal::FunctionInterface<R(P1, P2)>,
233  InputDomainIndex,
234  OutputToInputMapType,
235  VisitArrayType,
236  ThreadToOutputMapType,
237  DeviceAdapterTag>& invocation,
238  const ThreadIndicesType& threadIndices)
239 {
240  using Invocation = vtkm::internal::Invocation<ParameterInterface,
241  ControlInterface,
242  vtkm::internal::FunctionInterface<R(P1, P2)>,
243  InputDomainIndex,
244  OutputToInputMapType,
245  VisitArrayType,
246  ThreadToOutputMapType,
247  DeviceAdapterTag>;
248 
249  using FetchInfo1 = InvocationToFetch<ThreadIndicesType, Invocation, 1>;
250  using FetchType1 = typename FetchInfo1::type;
251  FetchType1 fetch1;
252  auto p1 =
253  fetch1.Load(threadIndices, FetchInfo1::GetParameter(invocation));
254 
255  using FetchInfo2 = InvocationToFetch<ThreadIndicesType, Invocation, 2>;
256  using FetchType2 = typename FetchInfo2::type;
257  FetchType2 fetch2;
258  auto p2 =
259  fetch2.Load(threadIndices, FetchInfo2::GetParameter(invocation));
260 
261  using FetchInfo0 = InvocationToFetch<ThreadIndicesType, Invocation, 0>;
262  using ReturnFetchType = typename FetchInfo0::type;
263  ReturnFetchType returnFetch;
264  // If you got a compile error on the following line, it probably means that
265  // the operator() of a worklet does not match the definition expected. One
266  // common problem is that the operator() method must be declared const. Check
267  // to make sure the "const" keyword is after parameters. Another common
268  // problem is that the type of one or more parameters is incompatible with
269  // the actual type that VTK-m creates in the execution environment. Make sure
270  // that the types of the worklet operator() parameters match those in the
271  // ExecutionSignature. The compiler error might help you narrow down which
272  // parameter is wrong and the types that did not match.
273  auto r = worklet(p1, p2);
274 
275  fetch1.Store(threadIndices, FetchInfo1::GetParameter(invocation), p1);
276  fetch2.Store(threadIndices, FetchInfo2::GetParameter(invocation), p2);
277 
278  returnFetch.Store(threadIndices, FetchInfo0::GetParameter(invocation), r);
279 }
280 
281 template <typename WorkletType,
282  typename ParameterInterface,
283  typename ControlInterface,
284  vtkm::IdComponent InputDomainIndex,
285  typename OutputToInputMapType,
286  typename VisitArrayType,
287  typename ThreadToOutputMapType,
288  typename DeviceAdapterTag,
289  typename ThreadIndicesType,
290  typename P1,
291  typename P2>
292 VTKM_EXEC void DoWorkletInvokeFunctor(
293  const WorkletType& worklet,
294  const vtkm::internal::Invocation<ParameterInterface,
295  ControlInterface,
296  vtkm::internal::FunctionInterface<void(P1, P2)>,
297  InputDomainIndex,
298  OutputToInputMapType,
299  VisitArrayType,
300  ThreadToOutputMapType,
301  DeviceAdapterTag>& invocation,
302  const ThreadIndicesType& threadIndices)
303 {
304  using Invocation =
305  vtkm::internal::Invocation<ParameterInterface,
306  ControlInterface,
307  vtkm::internal::FunctionInterface<void(P1, P2)>,
308  InputDomainIndex,
309  OutputToInputMapType,
310  VisitArrayType,
311  ThreadToOutputMapType,
312  DeviceAdapterTag>;
313 
314  using FetchInfo1 = InvocationToFetch<ThreadIndicesType, Invocation, 1>;
315  using FetchType1 = typename FetchInfo1::type;
316  FetchType1 fetch1;
317  auto p1 =
318  fetch1.Load(threadIndices, FetchInfo1::GetParameter(invocation));
319 
320  using FetchInfo2 = InvocationToFetch<ThreadIndicesType, Invocation, 2>;
321  using FetchType2 = typename FetchInfo2::type;
322  FetchType2 fetch2;
323  auto p2 =
324  fetch2.Load(threadIndices, FetchInfo2::GetParameter(invocation));
325 
326  // If you got a compile error on the following line, it probably means that
327  // the operator() of a worklet does not match the definition expected. One
328  // common problem is that the operator() method must be declared const. Check
329  // to make sure the "const" keyword is after parameters. Another common
330  // problem is that the type of one or more parameters is incompatible with
331  // the actual type that VTK-m creates in the execution environment. Make sure
332  // that the types of the worklet operator() parameters match those in the
333  // ExecutionSignature. The compiler error might help you narrow down which
334  // parameter is wrong and the types that did not match.
335  worklet(p1, p2);
336 
337  fetch1.Store(threadIndices, FetchInfo1::GetParameter(invocation), p1);
338  fetch2.Store(threadIndices, FetchInfo2::GetParameter(invocation), p2);
339 }
340 
341 template <typename WorkletType,
342  typename ParameterInterface,
343  typename ControlInterface,
344  vtkm::IdComponent InputDomainIndex,
345  typename OutputToInputMapType,
346  typename VisitArrayType,
347  typename ThreadToOutputMapType,
348  typename DeviceAdapterTag,
349  typename ThreadIndicesType,
350  typename R,
351  typename P1,
352  typename P2,
353  typename P3>
354 VTKM_EXEC void DoWorkletInvokeFunctor(
355  const WorkletType& worklet,
356  const vtkm::internal::Invocation<ParameterInterface,
357  ControlInterface,
358  vtkm::internal::FunctionInterface<R(P1, P2, P3)>,
359  InputDomainIndex,
360  OutputToInputMapType,
361  VisitArrayType,
362  ThreadToOutputMapType,
363  DeviceAdapterTag>& invocation,
364  const ThreadIndicesType& threadIndices)
365 {
366  using Invocation = vtkm::internal::Invocation<ParameterInterface,
367  ControlInterface,
368  vtkm::internal::FunctionInterface<R(P1, P2, P3)>,
369  InputDomainIndex,
370  OutputToInputMapType,
371  VisitArrayType,
372  ThreadToOutputMapType,
373  DeviceAdapterTag>;
374 
375  using FetchInfo1 = InvocationToFetch<ThreadIndicesType, Invocation, 1>;
376  using FetchType1 = typename FetchInfo1::type;
377  FetchType1 fetch1;
378  auto p1 =
379  fetch1.Load(threadIndices, FetchInfo1::GetParameter(invocation));
380 
381  using FetchInfo2 = InvocationToFetch<ThreadIndicesType, Invocation, 2>;
382  using FetchType2 = typename FetchInfo2::type;
383  FetchType2 fetch2;
384  auto p2 =
385  fetch2.Load(threadIndices, FetchInfo2::GetParameter(invocation));
386 
387  using FetchInfo3 = InvocationToFetch<ThreadIndicesType, Invocation, 3>;
388  using FetchType3 = typename FetchInfo3::type;
389  FetchType3 fetch3;
390  auto p3 =
391  fetch3.Load(threadIndices, FetchInfo3::GetParameter(invocation));
392 
393  using FetchInfo0 = InvocationToFetch<ThreadIndicesType, Invocation, 0>;
394  using ReturnFetchType = typename FetchInfo0::type;
395  ReturnFetchType returnFetch;
396  // If you got a compile error on the following line, it probably means that
397  // the operator() of a worklet does not match the definition expected. One
398  // common problem is that the operator() method must be declared const. Check
399  // to make sure the "const" keyword is after parameters. Another common
400  // problem is that the type of one or more parameters is incompatible with
401  // the actual type that VTK-m creates in the execution environment. Make sure
402  // that the types of the worklet operator() parameters match those in the
403  // ExecutionSignature. The compiler error might help you narrow down which
404  // parameter is wrong and the types that did not match.
405  auto r = worklet(p1, p2, p3);
406 
407  fetch1.Store(threadIndices, FetchInfo1::GetParameter(invocation), p1);
408  fetch2.Store(threadIndices, FetchInfo2::GetParameter(invocation), p2);
409  fetch3.Store(threadIndices, FetchInfo3::GetParameter(invocation), p3);
410 
411  returnFetch.Store(threadIndices, FetchInfo0::GetParameter(invocation), r);
412 }
413 
414 template <typename WorkletType,
415  typename ParameterInterface,
416  typename ControlInterface,
417  vtkm::IdComponent InputDomainIndex,
418  typename OutputToInputMapType,
419  typename VisitArrayType,
420  typename ThreadToOutputMapType,
421  typename DeviceAdapterTag,
422  typename ThreadIndicesType,
423  typename P1,
424  typename P2,
425  typename P3>
426 VTKM_EXEC void DoWorkletInvokeFunctor(
427  const WorkletType& worklet,
428  const vtkm::internal::Invocation<ParameterInterface,
429  ControlInterface,
430  vtkm::internal::FunctionInterface<void(P1, P2, P3)>,
431  InputDomainIndex,
432  OutputToInputMapType,
433  VisitArrayType,
434  ThreadToOutputMapType,
435  DeviceAdapterTag>& invocation,
436  const ThreadIndicesType& threadIndices)
437 {
438  using Invocation =
439  vtkm::internal::Invocation<ParameterInterface,
440  ControlInterface,
441  vtkm::internal::FunctionInterface<void(P1, P2, P3)>,
442  InputDomainIndex,
443  OutputToInputMapType,
444  VisitArrayType,
445  ThreadToOutputMapType,
446  DeviceAdapterTag>;
447 
448  using FetchInfo1 = InvocationToFetch<ThreadIndicesType, Invocation, 1>;
449  using FetchType1 = typename FetchInfo1::type;
450  FetchType1 fetch1;
451  auto p1 =
452  fetch1.Load(threadIndices, FetchInfo1::GetParameter(invocation));
453 
454  using FetchInfo2 = InvocationToFetch<ThreadIndicesType, Invocation, 2>;
455  using FetchType2 = typename FetchInfo2::type;
456  FetchType2 fetch2;
457  auto p2 =
458  fetch2.Load(threadIndices, FetchInfo2::GetParameter(invocation));
459 
460  using FetchInfo3 = InvocationToFetch<ThreadIndicesType, Invocation, 3>;
461  using FetchType3 = typename FetchInfo3::type;
462  FetchType3 fetch3;
463  auto p3 =
464  fetch3.Load(threadIndices, FetchInfo3::GetParameter(invocation));
465 
466  // If you got a compile error on the following line, it probably means that
467  // the operator() of a worklet does not match the definition expected. One
468  // common problem is that the operator() method must be declared const. Check
469  // to make sure the "const" keyword is after parameters. Another common
470  // problem is that the type of one or more parameters is incompatible with
471  // the actual type that VTK-m creates in the execution environment. Make sure
472  // that the types of the worklet operator() parameters match those in the
473  // ExecutionSignature. The compiler error might help you narrow down which
474  // parameter is wrong and the types that did not match.
475  worklet(p1, p2, p3);
476 
477  fetch1.Store(threadIndices, FetchInfo1::GetParameter(invocation), p1);
478  fetch2.Store(threadIndices, FetchInfo2::GetParameter(invocation), p2);
479  fetch3.Store(threadIndices, FetchInfo3::GetParameter(invocation), p3);
480 }
481 
482 template <typename WorkletType,
483  typename ParameterInterface,
484  typename ControlInterface,
485  vtkm::IdComponent InputDomainIndex,
486  typename OutputToInputMapType,
487  typename VisitArrayType,
488  typename ThreadToOutputMapType,
489  typename DeviceAdapterTag,
490  typename ThreadIndicesType,
491  typename R,
492  typename P1,
493  typename P2,
494  typename P3,
495  typename P4>
496 VTKM_EXEC void DoWorkletInvokeFunctor(
497  const WorkletType& worklet,
498  const vtkm::internal::Invocation<ParameterInterface,
499  ControlInterface,
500  vtkm::internal::FunctionInterface<R(P1, P2, P3, P4)>,
501  InputDomainIndex,
502  OutputToInputMapType,
503  VisitArrayType,
504  ThreadToOutputMapType,
505  DeviceAdapterTag>& invocation,
506  const ThreadIndicesType& threadIndices)
507 {
508  using Invocation = vtkm::internal::Invocation<ParameterInterface,
509  ControlInterface,
510  vtkm::internal::FunctionInterface<R(P1, P2, P3, P4)>,
511  InputDomainIndex,
512  OutputToInputMapType,
513  VisitArrayType,
514  ThreadToOutputMapType,
515  DeviceAdapterTag>;
516 
517  using FetchInfo1 = InvocationToFetch<ThreadIndicesType, Invocation, 1>;
518  using FetchType1 = typename FetchInfo1::type;
519  FetchType1 fetch1;
520  auto p1 =
521  fetch1.Load(threadIndices, FetchInfo1::GetParameter(invocation));
522 
523  using FetchInfo2 = InvocationToFetch<ThreadIndicesType, Invocation, 2>;
524  using FetchType2 = typename FetchInfo2::type;
525  FetchType2 fetch2;
526  auto p2 =
527  fetch2.Load(threadIndices, FetchInfo2::GetParameter(invocation));
528 
529  using FetchInfo3 = InvocationToFetch<ThreadIndicesType, Invocation, 3>;
530  using FetchType3 = typename FetchInfo3::type;
531  FetchType3 fetch3;
532  auto p3 =
533  fetch3.Load(threadIndices, FetchInfo3::GetParameter(invocation));
534 
535  using FetchInfo4 = InvocationToFetch<ThreadIndicesType, Invocation, 4>;
536  using FetchType4 = typename FetchInfo4::type;
537  FetchType4 fetch4;
538  auto p4 =
539  fetch4.Load(threadIndices, FetchInfo4::GetParameter(invocation));
540 
541  using FetchInfo0 = InvocationToFetch<ThreadIndicesType, Invocation, 0>;
542  using ReturnFetchType = typename FetchInfo0::type;
543  ReturnFetchType returnFetch;
544  // If you got a compile error on the following line, it probably means that
545  // the operator() of a worklet does not match the definition expected. One
546  // common problem is that the operator() method must be declared const. Check
547  // to make sure the "const" keyword is after parameters. Another common
548  // problem is that the type of one or more parameters is incompatible with
549  // the actual type that VTK-m creates in the execution environment. Make sure
550  // that the types of the worklet operator() parameters match those in the
551  // ExecutionSignature. The compiler error might help you narrow down which
552  // parameter is wrong and the types that did not match.
553  auto r = worklet(p1, p2, p3, p4);
554 
555  fetch1.Store(threadIndices, FetchInfo1::GetParameter(invocation), p1);
556  fetch2.Store(threadIndices, FetchInfo2::GetParameter(invocation), p2);
557  fetch3.Store(threadIndices, FetchInfo3::GetParameter(invocation), p3);
558  fetch4.Store(threadIndices, FetchInfo4::GetParameter(invocation), p4);
559 
560  returnFetch.Store(threadIndices, FetchInfo0::GetParameter(invocation), r);
561 }
562 
563 template <typename WorkletType,
564  typename ParameterInterface,
565  typename ControlInterface,
566  vtkm::IdComponent InputDomainIndex,
567  typename OutputToInputMapType,
568  typename VisitArrayType,
569  typename ThreadToOutputMapType,
570  typename DeviceAdapterTag,
571  typename ThreadIndicesType,
572  typename P1,
573  typename P2,
574  typename P3,
575  typename P4>
576 VTKM_EXEC void DoWorkletInvokeFunctor(
577  const WorkletType& worklet,
578  const vtkm::internal::Invocation<ParameterInterface,
579  ControlInterface,
580  vtkm::internal::FunctionInterface<void(P1, P2, P3, P4)>,
581  InputDomainIndex,
582  OutputToInputMapType,
583  VisitArrayType,
584  ThreadToOutputMapType,
585  DeviceAdapterTag>& invocation,
586  const ThreadIndicesType& threadIndices)
587 {
588  using Invocation =
589  vtkm::internal::Invocation<ParameterInterface,
590  ControlInterface,
591  vtkm::internal::FunctionInterface<void(P1, P2, P3, P4)>,
592  InputDomainIndex,
593  OutputToInputMapType,
594  VisitArrayType,
595  ThreadToOutputMapType,
596  DeviceAdapterTag>;
597 
598  using FetchInfo1 = InvocationToFetch<ThreadIndicesType, Invocation, 1>;
599  using FetchType1 = typename FetchInfo1::type;
600  FetchType1 fetch1;
601  auto p1 =
602  fetch1.Load(threadIndices, FetchInfo1::GetParameter(invocation));
603 
604  using FetchInfo2 = InvocationToFetch<ThreadIndicesType, Invocation, 2>;
605  using FetchType2 = typename FetchInfo2::type;
606  FetchType2 fetch2;
607  auto p2 =
608  fetch2.Load(threadIndices, FetchInfo2::GetParameter(invocation));
609 
610  using FetchInfo3 = InvocationToFetch<ThreadIndicesType, Invocation, 3>;
611  using FetchType3 = typename FetchInfo3::type;
612  FetchType3 fetch3;
613  auto p3 =
614  fetch3.Load(threadIndices, FetchInfo3::GetParameter(invocation));
615 
616  using FetchInfo4 = InvocationToFetch<ThreadIndicesType, Invocation, 4>;
617  using FetchType4 = typename FetchInfo4::type;
618  FetchType4 fetch4;
619  auto p4 =
620  fetch4.Load(threadIndices, FetchInfo4::GetParameter(invocation));
621 
622  // If you got a compile error on the following line, it probably means that
623  // the operator() of a worklet does not match the definition expected. One
624  // common problem is that the operator() method must be declared const. Check
625  // to make sure the "const" keyword is after parameters. Another common
626  // problem is that the type of one or more parameters is incompatible with
627  // the actual type that VTK-m creates in the execution environment. Make sure
628  // that the types of the worklet operator() parameters match those in the
629  // ExecutionSignature. The compiler error might help you narrow down which
630  // parameter is wrong and the types that did not match.
631  worklet(p1, p2, p3, p4);
632 
633  fetch1.Store(threadIndices, FetchInfo1::GetParameter(invocation), p1);
634  fetch2.Store(threadIndices, FetchInfo2::GetParameter(invocation), p2);
635  fetch3.Store(threadIndices, FetchInfo3::GetParameter(invocation), p3);
636  fetch4.Store(threadIndices, FetchInfo4::GetParameter(invocation), p4);
637 }
638 
639 template <typename WorkletType,
640  typename ParameterInterface,
641  typename ControlInterface,
642  vtkm::IdComponent InputDomainIndex,
643  typename OutputToInputMapType,
644  typename VisitArrayType,
645  typename ThreadToOutputMapType,
646  typename DeviceAdapterTag,
647  typename ThreadIndicesType,
648  typename R,
649  typename P1,
650  typename P2,
651  typename P3,
652  typename P4,
653  typename P5>
654 VTKM_EXEC void DoWorkletInvokeFunctor(
655  const WorkletType& worklet,
656  const vtkm::internal::Invocation<ParameterInterface,
657  ControlInterface,
658  vtkm::internal::FunctionInterface<R(P1, P2, P3, P4, P5)>,
659  InputDomainIndex,
660  OutputToInputMapType,
661  VisitArrayType,
662  ThreadToOutputMapType,
663  DeviceAdapterTag>& invocation,
664  const ThreadIndicesType& threadIndices)
665 {
666  using Invocation = vtkm::internal::Invocation<ParameterInterface,
667  ControlInterface,
668  vtkm::internal::FunctionInterface<R(P1, P2, P3, P4, P5)>,
669  InputDomainIndex,
670  OutputToInputMapType,
671  VisitArrayType,
672  ThreadToOutputMapType,
673  DeviceAdapterTag>;
674 
675  using FetchInfo1 = InvocationToFetch<ThreadIndicesType, Invocation, 1>;
676  using FetchType1 = typename FetchInfo1::type;
677  FetchType1 fetch1;
678  auto p1 =
679  fetch1.Load(threadIndices, FetchInfo1::GetParameter(invocation));
680 
681  using FetchInfo2 = InvocationToFetch<ThreadIndicesType, Invocation, 2>;
682  using FetchType2 = typename FetchInfo2::type;
683  FetchType2 fetch2;
684  auto p2 =
685  fetch2.Load(threadIndices, FetchInfo2::GetParameter(invocation));
686 
687  using FetchInfo3 = InvocationToFetch<ThreadIndicesType, Invocation, 3>;
688  using FetchType3 = typename FetchInfo3::type;
689  FetchType3 fetch3;
690  auto p3 =
691  fetch3.Load(threadIndices, FetchInfo3::GetParameter(invocation));
692 
693  using FetchInfo4 = InvocationToFetch<ThreadIndicesType, Invocation, 4>;
694  using FetchType4 = typename FetchInfo4::type;
695  FetchType4 fetch4;
696  auto p4 =
697  fetch4.Load(threadIndices, FetchInfo4::GetParameter(invocation));
698 
699  using FetchInfo5 = InvocationToFetch<ThreadIndicesType, Invocation, 5>;
700  using FetchType5 = typename FetchInfo5::type;
701  FetchType5 fetch5;
702  auto p5 =
703  fetch5.Load(threadIndices, FetchInfo5::GetParameter(invocation));
704 
705  using FetchInfo0 = InvocationToFetch<ThreadIndicesType, Invocation, 0>;
706  using ReturnFetchType = typename FetchInfo0::type;
707  ReturnFetchType returnFetch;
708  // If you got a compile error on the following line, it probably means that
709  // the operator() of a worklet does not match the definition expected. One
710  // common problem is that the operator() method must be declared const. Check
711  // to make sure the "const" keyword is after parameters. Another common
712  // problem is that the type of one or more parameters is incompatible with
713  // the actual type that VTK-m creates in the execution environment. Make sure
714  // that the types of the worklet operator() parameters match those in the
715  // ExecutionSignature. The compiler error might help you narrow down which
716  // parameter is wrong and the types that did not match.
717  auto r = worklet(p1, p2, p3, p4, p5);
718 
719  fetch1.Store(threadIndices, FetchInfo1::GetParameter(invocation), p1);
720  fetch2.Store(threadIndices, FetchInfo2::GetParameter(invocation), p2);
721  fetch3.Store(threadIndices, FetchInfo3::GetParameter(invocation), p3);
722  fetch4.Store(threadIndices, FetchInfo4::GetParameter(invocation), p4);
723  fetch5.Store(threadIndices, FetchInfo5::GetParameter(invocation), p5);
724 
725  returnFetch.Store(threadIndices, FetchInfo0::GetParameter(invocation), r);
726 }
727 
728 template <typename WorkletType,
729  typename ParameterInterface,
730  typename ControlInterface,
731  vtkm::IdComponent InputDomainIndex,
732  typename OutputToInputMapType,
733  typename VisitArrayType,
734  typename ThreadToOutputMapType,
735  typename DeviceAdapterTag,
736  typename ThreadIndicesType,
737  typename P1,
738  typename P2,
739  typename P3,
740  typename P4,
741  typename P5>
742 VTKM_EXEC void DoWorkletInvokeFunctor(
743  const WorkletType& worklet,
744  const vtkm::internal::Invocation<ParameterInterface,
745  ControlInterface,
746  vtkm::internal::FunctionInterface<void(P1, P2, P3, P4, P5)>,
747  InputDomainIndex,
748  OutputToInputMapType,
749  VisitArrayType,
750  ThreadToOutputMapType,
751  DeviceAdapterTag>& invocation,
752  const ThreadIndicesType& threadIndices)
753 {
754  using Invocation =
755  vtkm::internal::Invocation<ParameterInterface,
756  ControlInterface,
757  vtkm::internal::FunctionInterface<void(P1, P2, P3, P4, P5)>,
758  InputDomainIndex,
759  OutputToInputMapType,
760  VisitArrayType,
761  ThreadToOutputMapType,
762  DeviceAdapterTag>;
763 
764  using FetchInfo1 = InvocationToFetch<ThreadIndicesType, Invocation, 1>;
765  using FetchType1 = typename FetchInfo1::type;
766  FetchType1 fetch1;
767  auto p1 =
768  fetch1.Load(threadIndices, FetchInfo1::GetParameter(invocation));
769 
770  using FetchInfo2 = InvocationToFetch<ThreadIndicesType, Invocation, 2>;
771  using FetchType2 = typename FetchInfo2::type;
772  FetchType2 fetch2;
773  auto p2 =
774  fetch2.Load(threadIndices, FetchInfo2::GetParameter(invocation));
775 
776  using FetchInfo3 = InvocationToFetch<ThreadIndicesType, Invocation, 3>;
777  using FetchType3 = typename FetchInfo3::type;
778  FetchType3 fetch3;
779  auto p3 =
780  fetch3.Load(threadIndices, FetchInfo3::GetParameter(invocation));
781 
782  using FetchInfo4 = InvocationToFetch<ThreadIndicesType, Invocation, 4>;
783  using FetchType4 = typename FetchInfo4::type;
784  FetchType4 fetch4;
785  auto p4 =
786  fetch4.Load(threadIndices, FetchInfo4::GetParameter(invocation));
787 
788  using FetchInfo5 = InvocationToFetch<ThreadIndicesType, Invocation, 5>;
789  using FetchType5 = typename FetchInfo5::type;
790  FetchType5 fetch5;
791  auto p5 =
792  fetch5.Load(threadIndices, FetchInfo5::GetParameter(invocation));
793 
794  // If you got a compile error on the following line, it probably means that
795  // the operator() of a worklet does not match the definition expected. One
796  // common problem is that the operator() method must be declared const. Check
797  // to make sure the "const" keyword is after parameters. Another common
798  // problem is that the type of one or more parameters is incompatible with
799  // the actual type that VTK-m creates in the execution environment. Make sure
800  // that the types of the worklet operator() parameters match those in the
801  // ExecutionSignature. The compiler error might help you narrow down which
802  // parameter is wrong and the types that did not match.
803  worklet(p1, p2, p3, p4, p5);
804 
805  fetch1.Store(threadIndices, FetchInfo1::GetParameter(invocation), p1);
806  fetch2.Store(threadIndices, FetchInfo2::GetParameter(invocation), p2);
807  fetch3.Store(threadIndices, FetchInfo3::GetParameter(invocation), p3);
808  fetch4.Store(threadIndices, FetchInfo4::GetParameter(invocation), p4);
809  fetch5.Store(threadIndices, FetchInfo5::GetParameter(invocation), p5);
810 }
811 
812 template <typename WorkletType,
813  typename ParameterInterface,
814  typename ControlInterface,
815  vtkm::IdComponent InputDomainIndex,
816  typename OutputToInputMapType,
817  typename VisitArrayType,
818  typename ThreadToOutputMapType,
819  typename DeviceAdapterTag,
820  typename ThreadIndicesType,
821  typename R,
822  typename P1,
823  typename P2,
824  typename P3,
825  typename P4,
826  typename P5,
827  typename P6>
828 VTKM_EXEC void DoWorkletInvokeFunctor(
829  const WorkletType& worklet,
830  const vtkm::internal::Invocation<ParameterInterface,
831  ControlInterface,
832  vtkm::internal::FunctionInterface<R(P1, P2, P3, P4, P5, P6)>,
833  InputDomainIndex,
834  OutputToInputMapType,
835  VisitArrayType,
836  ThreadToOutputMapType,
837  DeviceAdapterTag>& invocation,
838  const ThreadIndicesType& threadIndices)
839 {
840  using Invocation = vtkm::internal::Invocation<ParameterInterface,
841  ControlInterface,
842  vtkm::internal::FunctionInterface<R(P1, P2, P3, P4, P5, P6)>,
843  InputDomainIndex,
844  OutputToInputMapType,
845  VisitArrayType,
846  ThreadToOutputMapType,
847  DeviceAdapterTag>;
848 
849  using FetchInfo1 = InvocationToFetch<ThreadIndicesType, Invocation, 1>;
850  using FetchType1 = typename FetchInfo1::type;
851  FetchType1 fetch1;
852  auto p1 =
853  fetch1.Load(threadIndices, FetchInfo1::GetParameter(invocation));
854 
855  using FetchInfo2 = InvocationToFetch<ThreadIndicesType, Invocation, 2>;
856  using FetchType2 = typename FetchInfo2::type;
857  FetchType2 fetch2;
858  auto p2 =
859  fetch2.Load(threadIndices, FetchInfo2::GetParameter(invocation));
860 
861  using FetchInfo3 = InvocationToFetch<ThreadIndicesType, Invocation, 3>;
862  using FetchType3 = typename FetchInfo3::type;
863  FetchType3 fetch3;
864  auto p3 =
865  fetch3.Load(threadIndices, FetchInfo3::GetParameter(invocation));
866 
867  using FetchInfo4 = InvocationToFetch<ThreadIndicesType, Invocation, 4>;
868  using FetchType4 = typename FetchInfo4::type;
869  FetchType4 fetch4;
870  auto p4 =
871  fetch4.Load(threadIndices, FetchInfo4::GetParameter(invocation));
872 
873  using FetchInfo5 = InvocationToFetch<ThreadIndicesType, Invocation, 5>;
874  using FetchType5 = typename FetchInfo5::type;
875  FetchType5 fetch5;
876  auto p5 =
877  fetch5.Load(threadIndices, FetchInfo5::GetParameter(invocation));
878 
879  using FetchInfo6 = InvocationToFetch<ThreadIndicesType, Invocation, 6>;
880  using FetchType6 = typename FetchInfo6::type;
881  FetchType6 fetch6;
882  auto p6 =
883  fetch6.Load(threadIndices, FetchInfo6::GetParameter(invocation));
884 
885  using FetchInfo0 = InvocationToFetch<ThreadIndicesType, Invocation, 0>;
886  using ReturnFetchType = typename FetchInfo0::type;
887  ReturnFetchType returnFetch;
888  // If you got a compile error on the following line, it probably means that
889  // the operator() of a worklet does not match the definition expected. One
890  // common problem is that the operator() method must be declared const. Check
891  // to make sure the "const" keyword is after parameters. Another common
892  // problem is that the type of one or more parameters is incompatible with
893  // the actual type that VTK-m creates in the execution environment. Make sure
894  // that the types of the worklet operator() parameters match those in the
895  // ExecutionSignature. The compiler error might help you narrow down which
896  // parameter is wrong and the types that did not match.
897  auto r = worklet(p1, p2, p3, p4, p5, p6);
898 
899  fetch1.Store(threadIndices, FetchInfo1::GetParameter(invocation), p1);
900  fetch2.Store(threadIndices, FetchInfo2::GetParameter(invocation), p2);
901  fetch3.Store(threadIndices, FetchInfo3::GetParameter(invocation), p3);
902  fetch4.Store(threadIndices, FetchInfo4::GetParameter(invocation), p4);
903  fetch5.Store(threadIndices, FetchInfo5::GetParameter(invocation), p5);
904  fetch6.Store(threadIndices, FetchInfo6::GetParameter(invocation), p6);
905 
906  returnFetch.Store(threadIndices, FetchInfo0::GetParameter(invocation), r);
907 }
908 
909 template <typename WorkletType,
910  typename ParameterInterface,
911  typename ControlInterface,
912  vtkm::IdComponent InputDomainIndex,
913  typename OutputToInputMapType,
914  typename VisitArrayType,
915  typename ThreadToOutputMapType,
916  typename DeviceAdapterTag,
917  typename ThreadIndicesType,
918  typename P1,
919  typename P2,
920  typename P3,
921  typename P4,
922  typename P5,
923  typename P6>
924 VTKM_EXEC void DoWorkletInvokeFunctor(
925  const WorkletType& worklet,
926  const vtkm::internal::Invocation<ParameterInterface,
927  ControlInterface,
928  vtkm::internal::FunctionInterface<void(P1, P2, P3, P4, P5, P6)>,
929  InputDomainIndex,
930  OutputToInputMapType,
931  VisitArrayType,
932  ThreadToOutputMapType,
933  DeviceAdapterTag>& invocation,
934  const ThreadIndicesType& threadIndices)
935 {
936  using Invocation =
937  vtkm::internal::Invocation<ParameterInterface,
938  ControlInterface,
939  vtkm::internal::FunctionInterface<void(P1, P2, P3, P4, P5, P6)>,
940  InputDomainIndex,
941  OutputToInputMapType,
942  VisitArrayType,
943  ThreadToOutputMapType,
944  DeviceAdapterTag>;
945 
946  using FetchInfo1 = InvocationToFetch<ThreadIndicesType, Invocation, 1>;
947  using FetchType1 = typename FetchInfo1::type;
948  FetchType1 fetch1;
949  auto p1 =
950  fetch1.Load(threadIndices, FetchInfo1::GetParameter(invocation));
951 
952  using FetchInfo2 = InvocationToFetch<ThreadIndicesType, Invocation, 2>;
953  using FetchType2 = typename FetchInfo2::type;
954  FetchType2 fetch2;
955  auto p2 =
956  fetch2.Load(threadIndices, FetchInfo2::GetParameter(invocation));
957 
958  using FetchInfo3 = InvocationToFetch<ThreadIndicesType, Invocation, 3>;
959  using FetchType3 = typename FetchInfo3::type;
960  FetchType3 fetch3;
961  auto p3 =
962  fetch3.Load(threadIndices, FetchInfo3::GetParameter(invocation));
963 
964  using FetchInfo4 = InvocationToFetch<ThreadIndicesType, Invocation, 4>;
965  using FetchType4 = typename FetchInfo4::type;
966  FetchType4 fetch4;
967  auto p4 =
968  fetch4.Load(threadIndices, FetchInfo4::GetParameter(invocation));
969 
970  using FetchInfo5 = InvocationToFetch<ThreadIndicesType, Invocation, 5>;
971  using FetchType5 = typename FetchInfo5::type;
972  FetchType5 fetch5;
973  auto p5 =
974  fetch5.Load(threadIndices, FetchInfo5::GetParameter(invocation));
975 
976  using FetchInfo6 = InvocationToFetch<ThreadIndicesType, Invocation, 6>;
977  using FetchType6 = typename FetchInfo6::type;
978  FetchType6 fetch6;
979  auto p6 =
980  fetch6.Load(threadIndices, FetchInfo6::GetParameter(invocation));
981 
982  // If you got a compile error on the following line, it probably means that
983  // the operator() of a worklet does not match the definition expected. One
984  // common problem is that the operator() method must be declared const. Check
985  // to make sure the "const" keyword is after parameters. Another common
986  // problem is that the type of one or more parameters is incompatible with
987  // the actual type that VTK-m creates in the execution environment. Make sure
988  // that the types of the worklet operator() parameters match those in the
989  // ExecutionSignature. The compiler error might help you narrow down which
990  // parameter is wrong and the types that did not match.
991  worklet(p1, p2, p3, p4, p5, p6);
992 
993  fetch1.Store(threadIndices, FetchInfo1::GetParameter(invocation), p1);
994  fetch2.Store(threadIndices, FetchInfo2::GetParameter(invocation), p2);
995  fetch3.Store(threadIndices, FetchInfo3::GetParameter(invocation), p3);
996  fetch4.Store(threadIndices, FetchInfo4::GetParameter(invocation), p4);
997  fetch5.Store(threadIndices, FetchInfo5::GetParameter(invocation), p5);
998  fetch6.Store(threadIndices, FetchInfo6::GetParameter(invocation), p6);
999 }
1000 
1001 template <typename WorkletType,
1002  typename ParameterInterface,
1003  typename ControlInterface,
1004  vtkm::IdComponent InputDomainIndex,
1005  typename OutputToInputMapType,
1006  typename VisitArrayType,
1007  typename ThreadToOutputMapType,
1008  typename DeviceAdapterTag,
1009  typename ThreadIndicesType,
1010  typename R,
1011  typename P1,
1012  typename P2,
1013  typename P3,
1014  typename P4,
1015  typename P5,
1016  typename P6,
1017  typename P7>
1018 VTKM_EXEC void DoWorkletInvokeFunctor(
1019  const WorkletType& worklet,
1020  const vtkm::internal::Invocation<ParameterInterface,
1021  ControlInterface,
1022  vtkm::internal::FunctionInterface<R(P1, P2, P3, P4, P5, P6, P7)>,
1023  InputDomainIndex,
1024  OutputToInputMapType,
1025  VisitArrayType,
1026  ThreadToOutputMapType,
1027  DeviceAdapterTag>& invocation,
1028  const ThreadIndicesType& threadIndices)
1029 {
1030  using Invocation = vtkm::internal::Invocation<ParameterInterface,
1031  ControlInterface,
1032  vtkm::internal::FunctionInterface<R(P1, P2, P3, P4, P5, P6, P7)>,
1033  InputDomainIndex,
1034  OutputToInputMapType,
1035  VisitArrayType,
1036  ThreadToOutputMapType,
1037  DeviceAdapterTag>;
1038 
1039  using FetchInfo1 = InvocationToFetch<ThreadIndicesType, Invocation, 1>;
1040  using FetchType1 = typename FetchInfo1::type;
1041  FetchType1 fetch1;
1042  auto p1 =
1043  fetch1.Load(threadIndices, FetchInfo1::GetParameter(invocation));
1044 
1045  using FetchInfo2 = InvocationToFetch<ThreadIndicesType, Invocation, 2>;
1046  using FetchType2 = typename FetchInfo2::type;
1047  FetchType2 fetch2;
1048  auto p2 =
1049  fetch2.Load(threadIndices, FetchInfo2::GetParameter(invocation));
1050 
1051  using FetchInfo3 = InvocationToFetch<ThreadIndicesType, Invocation, 3>;
1052  using FetchType3 = typename FetchInfo3::type;
1053  FetchType3 fetch3;
1054  auto p3 =
1055  fetch3.Load(threadIndices, FetchInfo3::GetParameter(invocation));
1056 
1057  using FetchInfo4 = InvocationToFetch<ThreadIndicesType, Invocation, 4>;
1058  using FetchType4 = typename FetchInfo4::type;
1059  FetchType4 fetch4;
1060  auto p4 =
1061  fetch4.Load(threadIndices, FetchInfo4::GetParameter(invocation));
1062 
1063  using FetchInfo5 = InvocationToFetch<ThreadIndicesType, Invocation, 5>;
1064  using FetchType5 = typename FetchInfo5::type;
1065  FetchType5 fetch5;
1066  auto p5 =
1067  fetch5.Load(threadIndices, FetchInfo5::GetParameter(invocation));
1068 
1069  using FetchInfo6 = InvocationToFetch<ThreadIndicesType, Invocation, 6>;
1070  using FetchType6 = typename FetchInfo6::type;
1071  FetchType6 fetch6;
1072  auto p6 =
1073  fetch6.Load(threadIndices, FetchInfo6::GetParameter(invocation));
1074 
1075  using FetchInfo7 = InvocationToFetch<ThreadIndicesType, Invocation, 7>;
1076  using FetchType7 = typename FetchInfo7::type;
1077  FetchType7 fetch7;
1078  auto p7 =
1079  fetch7.Load(threadIndices, FetchInfo7::GetParameter(invocation));
1080 
1081  using FetchInfo0 = InvocationToFetch<ThreadIndicesType, Invocation, 0>;
1082  using ReturnFetchType = typename FetchInfo0::type;
1083  ReturnFetchType returnFetch;
1084  // If you got a compile error on the following line, it probably means that
1085  // the operator() of a worklet does not match the definition expected. One
1086  // common problem is that the operator() method must be declared const. Check
1087  // to make sure the "const" keyword is after parameters. Another common
1088  // problem is that the type of one or more parameters is incompatible with
1089  // the actual type that VTK-m creates in the execution environment. Make sure
1090  // that the types of the worklet operator() parameters match those in the
1091  // ExecutionSignature. The compiler error might help you narrow down which
1092  // parameter is wrong and the types that did not match.
1093  auto r = worklet(p1, p2, p3, p4, p5, p6, p7);
1094 
1095  fetch1.Store(threadIndices, FetchInfo1::GetParameter(invocation), p1);
1096  fetch2.Store(threadIndices, FetchInfo2::GetParameter(invocation), p2);
1097  fetch3.Store(threadIndices, FetchInfo3::GetParameter(invocation), p3);
1098  fetch4.Store(threadIndices, FetchInfo4::GetParameter(invocation), p4);
1099  fetch5.Store(threadIndices, FetchInfo5::GetParameter(invocation), p5);
1100  fetch6.Store(threadIndices, FetchInfo6::GetParameter(invocation), p6);
1101  fetch7.Store(threadIndices, FetchInfo7::GetParameter(invocation), p7);
1102 
1103  returnFetch.Store(threadIndices, FetchInfo0::GetParameter(invocation), r);
1104 }
1105 
1106 template <typename WorkletType,
1107  typename ParameterInterface,
1108  typename ControlInterface,
1109  vtkm::IdComponent InputDomainIndex,
1110  typename OutputToInputMapType,
1111  typename VisitArrayType,
1112  typename ThreadToOutputMapType,
1113  typename DeviceAdapterTag,
1114  typename ThreadIndicesType,
1115  typename P1,
1116  typename P2,
1117  typename P3,
1118  typename P4,
1119  typename P5,
1120  typename P6,
1121  typename P7>
1122 VTKM_EXEC void DoWorkletInvokeFunctor(
1123  const WorkletType& worklet,
1124  const vtkm::internal::Invocation<ParameterInterface,
1125  ControlInterface,
1126  vtkm::internal::FunctionInterface<void(P1, P2, P3, P4, P5, P6, P7)>,
1127  InputDomainIndex,
1128  OutputToInputMapType,
1129  VisitArrayType,
1130  ThreadToOutputMapType,
1131  DeviceAdapterTag>& invocation,
1132  const ThreadIndicesType& threadIndices)
1133 {
1134  using Invocation =
1135  vtkm::internal::Invocation<ParameterInterface,
1136  ControlInterface,
1137  vtkm::internal::FunctionInterface<void(P1, P2, P3, P4, P5, P6, P7)>,
1138  InputDomainIndex,
1139  OutputToInputMapType,
1140  VisitArrayType,
1141  ThreadToOutputMapType,
1142  DeviceAdapterTag>;
1143 
1144  using FetchInfo1 = InvocationToFetch<ThreadIndicesType, Invocation, 1>;
1145  using FetchType1 = typename FetchInfo1::type;
1146  FetchType1 fetch1;
1147  auto p1 =
1148  fetch1.Load(threadIndices, FetchInfo1::GetParameter(invocation));
1149 
1150  using FetchInfo2 = InvocationToFetch<ThreadIndicesType, Invocation, 2>;
1151  using FetchType2 = typename FetchInfo2::type;
1152  FetchType2 fetch2;
1153  auto p2 =
1154  fetch2.Load(threadIndices, FetchInfo2::GetParameter(invocation));
1155 
1156  using FetchInfo3 = InvocationToFetch<ThreadIndicesType, Invocation, 3>;
1157  using FetchType3 = typename FetchInfo3::type;
1158  FetchType3 fetch3;
1159  auto p3 =
1160  fetch3.Load(threadIndices, FetchInfo3::GetParameter(invocation));
1161 
1162  using FetchInfo4 = InvocationToFetch<ThreadIndicesType, Invocation, 4>;
1163  using FetchType4 = typename FetchInfo4::type;
1164  FetchType4 fetch4;
1165  auto p4 =
1166  fetch4.Load(threadIndices, FetchInfo4::GetParameter(invocation));
1167 
1168  using FetchInfo5 = InvocationToFetch<ThreadIndicesType, Invocation, 5>;
1169  using FetchType5 = typename FetchInfo5::type;
1170  FetchType5 fetch5;
1171  auto p5 =
1172  fetch5.Load(threadIndices, FetchInfo5::GetParameter(invocation));
1173 
1174  using FetchInfo6 = InvocationToFetch<ThreadIndicesType, Invocation, 6>;
1175  using FetchType6 = typename FetchInfo6::type;
1176  FetchType6 fetch6;
1177  auto p6 =
1178  fetch6.Load(threadIndices, FetchInfo6::GetParameter(invocation));
1179 
1180  using FetchInfo7 = InvocationToFetch<ThreadIndicesType, Invocation, 7>;
1181  using FetchType7 = typename FetchInfo7::type;
1182  FetchType7 fetch7;
1183  auto p7 =
1184  fetch7.Load(threadIndices, FetchInfo7::GetParameter(invocation));
1185 
1186  // If you got a compile error on the following line, it probably means that
1187  // the operator() of a worklet does not match the definition expected. One
1188  // common problem is that the operator() method must be declared const. Check
1189  // to make sure the "const" keyword is after parameters. Another common
1190  // problem is that the type of one or more parameters is incompatible with
1191  // the actual type that VTK-m creates in the execution environment. Make sure
1192  // that the types of the worklet operator() parameters match those in the
1193  // ExecutionSignature. The compiler error might help you narrow down which
1194  // parameter is wrong and the types that did not match.
1195  worklet(p1, p2, p3, p4, p5, p6, p7);
1196 
1197  fetch1.Store(threadIndices, FetchInfo1::GetParameter(invocation), p1);
1198  fetch2.Store(threadIndices, FetchInfo2::GetParameter(invocation), p2);
1199  fetch3.Store(threadIndices, FetchInfo3::GetParameter(invocation), p3);
1200  fetch4.Store(threadIndices, FetchInfo4::GetParameter(invocation), p4);
1201  fetch5.Store(threadIndices, FetchInfo5::GetParameter(invocation), p5);
1202  fetch6.Store(threadIndices, FetchInfo6::GetParameter(invocation), p6);
1203  fetch7.Store(threadIndices, FetchInfo7::GetParameter(invocation), p7);
1204 }
1205 
1206 template <typename WorkletType,
1207  typename ParameterInterface,
1208  typename ControlInterface,
1209  vtkm::IdComponent InputDomainIndex,
1210  typename OutputToInputMapType,
1211  typename VisitArrayType,
1212  typename ThreadToOutputMapType,
1213  typename DeviceAdapterTag,
1214  typename ThreadIndicesType,
1215  typename R,
1216  typename P1,
1217  typename P2,
1218  typename P3,
1219  typename P4,
1220  typename P5,
1221  typename P6,
1222  typename P7,
1223  typename P8>
1224 VTKM_EXEC void DoWorkletInvokeFunctor(
1225  const WorkletType& worklet,
1226  const vtkm::internal::Invocation<ParameterInterface,
1227  ControlInterface,
1228  vtkm::internal::FunctionInterface<R(P1, P2, P3, P4, P5, P6, P7, P8)>,
1229  InputDomainIndex,
1230  OutputToInputMapType,
1231  VisitArrayType,
1232  ThreadToOutputMapType,
1233  DeviceAdapterTag>& invocation,
1234  const ThreadIndicesType& threadIndices)
1235 {
1236  using Invocation = vtkm::internal::Invocation<ParameterInterface,
1237  ControlInterface,
1238  vtkm::internal::FunctionInterface<R(P1, P2, P3, P4, P5, P6, P7, P8)>,
1239  InputDomainIndex,
1240  OutputToInputMapType,
1241  VisitArrayType,
1242  ThreadToOutputMapType,
1243  DeviceAdapterTag>;
1244 
1245  using FetchInfo1 = InvocationToFetch<ThreadIndicesType, Invocation, 1>;
1246  using FetchType1 = typename FetchInfo1::type;
1247  FetchType1 fetch1;
1248  auto p1 =
1249  fetch1.Load(threadIndices, FetchInfo1::GetParameter(invocation));
1250 
1251  using FetchInfo2 = InvocationToFetch<ThreadIndicesType, Invocation, 2>;
1252  using FetchType2 = typename FetchInfo2::type;
1253  FetchType2 fetch2;
1254  auto p2 =
1255  fetch2.Load(threadIndices, FetchInfo2::GetParameter(invocation));
1256 
1257  using FetchInfo3 = InvocationToFetch<ThreadIndicesType, Invocation, 3>;
1258  using FetchType3 = typename FetchInfo3::type;
1259  FetchType3 fetch3;
1260  auto p3 =
1261  fetch3.Load(threadIndices, FetchInfo3::GetParameter(invocation));
1262 
1263  using FetchInfo4 = InvocationToFetch<ThreadIndicesType, Invocation, 4>;
1264  using FetchType4 = typename FetchInfo4::type;
1265  FetchType4 fetch4;
1266  auto p4 =
1267  fetch4.Load(threadIndices, FetchInfo4::GetParameter(invocation));
1268 
1269  using FetchInfo5 = InvocationToFetch<ThreadIndicesType, Invocation, 5>;
1270  using FetchType5 = typename FetchInfo5::type;
1271  FetchType5 fetch5;
1272  auto p5 =
1273  fetch5.Load(threadIndices, FetchInfo5::GetParameter(invocation));
1274 
1275  using FetchInfo6 = InvocationToFetch<ThreadIndicesType, Invocation, 6>;
1276  using FetchType6 = typename FetchInfo6::type;
1277  FetchType6 fetch6;
1278  auto p6 =
1279  fetch6.Load(threadIndices, FetchInfo6::GetParameter(invocation));
1280 
1281  using FetchInfo7 = InvocationToFetch<ThreadIndicesType, Invocation, 7>;
1282  using FetchType7 = typename FetchInfo7::type;
1283  FetchType7 fetch7;
1284  auto p7 =
1285  fetch7.Load(threadIndices, FetchInfo7::GetParameter(invocation));
1286 
1287  using FetchInfo8 = InvocationToFetch<ThreadIndicesType, Invocation, 8>;
1288  using FetchType8 = typename FetchInfo8::type;
1289  FetchType8 fetch8;
1290  auto p8 =
1291  fetch8.Load(threadIndices, FetchInfo8::GetParameter(invocation));
1292 
1293  using FetchInfo0 = InvocationToFetch<ThreadIndicesType, Invocation, 0>;
1294  using ReturnFetchType = typename FetchInfo0::type;
1295  ReturnFetchType returnFetch;
1296  // If you got a compile error on the following line, it probably means that
1297  // the operator() of a worklet does not match the definition expected. One
1298  // common problem is that the operator() method must be declared const. Check
1299  // to make sure the "const" keyword is after parameters. Another common
1300  // problem is that the type of one or more parameters is incompatible with
1301  // the actual type that VTK-m creates in the execution environment. Make sure
1302  // that the types of the worklet operator() parameters match those in the
1303  // ExecutionSignature. The compiler error might help you narrow down which
1304  // parameter is wrong and the types that did not match.
1305  auto r = worklet(p1, p2, p3, p4, p5, p6, p7, p8);
1306 
1307  fetch1.Store(threadIndices, FetchInfo1::GetParameter(invocation), p1);
1308  fetch2.Store(threadIndices, FetchInfo2::GetParameter(invocation), p2);
1309  fetch3.Store(threadIndices, FetchInfo3::GetParameter(invocation), p3);
1310  fetch4.Store(threadIndices, FetchInfo4::GetParameter(invocation), p4);
1311  fetch5.Store(threadIndices, FetchInfo5::GetParameter(invocation), p5);
1312  fetch6.Store(threadIndices, FetchInfo6::GetParameter(invocation), p6);
1313  fetch7.Store(threadIndices, FetchInfo7::GetParameter(invocation), p7);
1314  fetch8.Store(threadIndices, FetchInfo8::GetParameter(invocation), p8);
1315 
1316  returnFetch.Store(threadIndices, FetchInfo0::GetParameter(invocation), r);
1317 }
1318 
1319 template <typename WorkletType,
1320  typename ParameterInterface,
1321  typename ControlInterface,
1322  vtkm::IdComponent InputDomainIndex,
1323  typename OutputToInputMapType,
1324  typename VisitArrayType,
1325  typename ThreadToOutputMapType,
1326  typename DeviceAdapterTag,
1327  typename ThreadIndicesType,
1328  typename P1,
1329  typename P2,
1330  typename P3,
1331  typename P4,
1332  typename P5,
1333  typename P6,
1334  typename P7,
1335  typename P8>
1336 VTKM_EXEC void DoWorkletInvokeFunctor(
1337  const WorkletType& worklet,
1338  const vtkm::internal::Invocation<ParameterInterface,
1339  ControlInterface,
1340  vtkm::internal::FunctionInterface<void(P1, P2, P3, P4, P5, P6, P7, P8)>,
1341  InputDomainIndex,
1342  OutputToInputMapType,
1343  VisitArrayType,
1344  ThreadToOutputMapType,
1345  DeviceAdapterTag>& invocation,
1346  const ThreadIndicesType& threadIndices)
1347 {
1348  using Invocation =
1349  vtkm::internal::Invocation<ParameterInterface,
1350  ControlInterface,
1351  vtkm::internal::FunctionInterface<void(P1, P2, P3, P4, P5, P6, P7, P8)>,
1352  InputDomainIndex,
1353  OutputToInputMapType,
1354  VisitArrayType,
1355  ThreadToOutputMapType,
1356  DeviceAdapterTag>;
1357 
1358  using FetchInfo1 = InvocationToFetch<ThreadIndicesType, Invocation, 1>;
1359  using FetchType1 = typename FetchInfo1::type;
1360  FetchType1 fetch1;
1361  auto p1 =
1362  fetch1.Load(threadIndices, FetchInfo1::GetParameter(invocation));
1363 
1364  using FetchInfo2 = InvocationToFetch<ThreadIndicesType, Invocation, 2>;
1365  using FetchType2 = typename FetchInfo2::type;
1366  FetchType2 fetch2;
1367  auto p2 =
1368  fetch2.Load(threadIndices, FetchInfo2::GetParameter(invocation));
1369 
1370  using FetchInfo3 = InvocationToFetch<ThreadIndicesType, Invocation, 3>;
1371  using FetchType3 = typename FetchInfo3::type;
1372  FetchType3 fetch3;
1373  auto p3 =
1374  fetch3.Load(threadIndices, FetchInfo3::GetParameter(invocation));
1375 
1376  using FetchInfo4 = InvocationToFetch<ThreadIndicesType, Invocation, 4>;
1377  using FetchType4 = typename FetchInfo4::type;
1378  FetchType4 fetch4;
1379  auto p4 =
1380  fetch4.Load(threadIndices, FetchInfo4::GetParameter(invocation));
1381 
1382  using FetchInfo5 = InvocationToFetch<ThreadIndicesType, Invocation, 5>;
1383  using FetchType5 = typename FetchInfo5::type;
1384  FetchType5 fetch5;
1385  auto p5 =
1386  fetch5.Load(threadIndices, FetchInfo5::GetParameter(invocation));
1387 
1388  using FetchInfo6 = InvocationToFetch<ThreadIndicesType, Invocation, 6>;
1389  using FetchType6 = typename FetchInfo6::type;
1390  FetchType6 fetch6;
1391  auto p6 =
1392  fetch6.Load(threadIndices, FetchInfo6::GetParameter(invocation));
1393 
1394  using FetchInfo7 = InvocationToFetch<ThreadIndicesType, Invocation, 7>;
1395  using FetchType7 = typename FetchInfo7::type;
1396  FetchType7 fetch7;
1397  auto p7 =
1398  fetch7.Load(threadIndices, FetchInfo7::GetParameter(invocation));
1399 
1400  using FetchInfo8 = InvocationToFetch<ThreadIndicesType, Invocation, 8>;
1401  using FetchType8 = typename FetchInfo8::type;
1402  FetchType8 fetch8;
1403  auto p8 =
1404  fetch8.Load(threadIndices, FetchInfo8::GetParameter(invocation));
1405 
1406  // If you got a compile error on the following line, it probably means that
1407  // the operator() of a worklet does not match the definition expected. One
1408  // common problem is that the operator() method must be declared const. Check
1409  // to make sure the "const" keyword is after parameters. Another common
1410  // problem is that the type of one or more parameters is incompatible with
1411  // the actual type that VTK-m creates in the execution environment. Make sure
1412  // that the types of the worklet operator() parameters match those in the
1413  // ExecutionSignature. The compiler error might help you narrow down which
1414  // parameter is wrong and the types that did not match.
1415  worklet(p1, p2, p3, p4, p5, p6, p7, p8);
1416 
1417  fetch1.Store(threadIndices, FetchInfo1::GetParameter(invocation), p1);
1418  fetch2.Store(threadIndices, FetchInfo2::GetParameter(invocation), p2);
1419  fetch3.Store(threadIndices, FetchInfo3::GetParameter(invocation), p3);
1420  fetch4.Store(threadIndices, FetchInfo4::GetParameter(invocation), p4);
1421  fetch5.Store(threadIndices, FetchInfo5::GetParameter(invocation), p5);
1422  fetch6.Store(threadIndices, FetchInfo6::GetParameter(invocation), p6);
1423  fetch7.Store(threadIndices, FetchInfo7::GetParameter(invocation), p7);
1424  fetch8.Store(threadIndices, FetchInfo8::GetParameter(invocation), p8);
1425 }
1426 
1427 template <typename WorkletType,
1428  typename ParameterInterface,
1429  typename ControlInterface,
1430  vtkm::IdComponent InputDomainIndex,
1431  typename OutputToInputMapType,
1432  typename VisitArrayType,
1433  typename ThreadToOutputMapType,
1434  typename DeviceAdapterTag,
1435  typename ThreadIndicesType,
1436  typename R,
1437  typename P1,
1438  typename P2,
1439  typename P3,
1440  typename P4,
1441  typename P5,
1442  typename P6,
1443  typename P7,
1444  typename P8,
1445  typename P9>
1446 VTKM_EXEC void DoWorkletInvokeFunctor(
1447  const WorkletType& worklet,
1448  const vtkm::internal::Invocation<ParameterInterface,
1449  ControlInterface,
1450  vtkm::internal::FunctionInterface<R(P1, P2, P3, P4, P5, P6, P7, P8, P9)>,
1451  InputDomainIndex,
1452  OutputToInputMapType,
1453  VisitArrayType,
1454  ThreadToOutputMapType,
1455  DeviceAdapterTag>& invocation,
1456  const ThreadIndicesType& threadIndices)
1457 {
1458  using Invocation = vtkm::internal::Invocation<ParameterInterface,
1459  ControlInterface,
1460  vtkm::internal::FunctionInterface<R(P1, P2, P3, P4, P5, P6, P7, P8, P9)>,
1461  InputDomainIndex,
1462  OutputToInputMapType,
1463  VisitArrayType,
1464  ThreadToOutputMapType,
1465  DeviceAdapterTag>;
1466 
1467  using FetchInfo1 = InvocationToFetch<ThreadIndicesType, Invocation, 1>;
1468  using FetchType1 = typename FetchInfo1::type;
1469  FetchType1 fetch1;
1470  auto p1 =
1471  fetch1.Load(threadIndices, FetchInfo1::GetParameter(invocation));
1472 
1473  using FetchInfo2 = InvocationToFetch<ThreadIndicesType, Invocation, 2>;
1474  using FetchType2 = typename FetchInfo2::type;
1475  FetchType2 fetch2;
1476  auto p2 =
1477  fetch2.Load(threadIndices, FetchInfo2::GetParameter(invocation));
1478 
1479  using FetchInfo3 = InvocationToFetch<ThreadIndicesType, Invocation, 3>;
1480  using FetchType3 = typename FetchInfo3::type;
1481  FetchType3 fetch3;
1482  auto p3 =
1483  fetch3.Load(threadIndices, FetchInfo3::GetParameter(invocation));
1484 
1485  using FetchInfo4 = InvocationToFetch<ThreadIndicesType, Invocation, 4>;
1486  using FetchType4 = typename FetchInfo4::type;
1487  FetchType4 fetch4;
1488  auto p4 =
1489  fetch4.Load(threadIndices, FetchInfo4::GetParameter(invocation));
1490 
1491  using FetchInfo5 = InvocationToFetch<ThreadIndicesType, Invocation, 5>;
1492  using FetchType5 = typename FetchInfo5::type;
1493  FetchType5 fetch5;
1494  auto p5 =
1495  fetch5.Load(threadIndices, FetchInfo5::GetParameter(invocation));
1496 
1497  using FetchInfo6 = InvocationToFetch<ThreadIndicesType, Invocation, 6>;
1498  using FetchType6 = typename FetchInfo6::type;
1499  FetchType6 fetch6;
1500  auto p6 =
1501  fetch6.Load(threadIndices, FetchInfo6::GetParameter(invocation));
1502 
1503  using FetchInfo7 = InvocationToFetch<ThreadIndicesType, Invocation, 7>;
1504  using FetchType7 = typename FetchInfo7::type;
1505  FetchType7 fetch7;
1506  auto p7 =
1507  fetch7.Load(threadIndices, FetchInfo7::GetParameter(invocation));
1508 
1509  using FetchInfo8 = InvocationToFetch<ThreadIndicesType, Invocation, 8>;
1510  using FetchType8 = typename FetchInfo8::type;
1511  FetchType8 fetch8;
1512  auto p8 =
1513  fetch8.Load(threadIndices, FetchInfo8::GetParameter(invocation));
1514 
1515  using FetchInfo9 = InvocationToFetch<ThreadIndicesType, Invocation, 9>;
1516  using FetchType9 = typename FetchInfo9::type;
1517  FetchType9 fetch9;
1518  auto p9 =
1519  fetch9.Load(threadIndices, FetchInfo9::GetParameter(invocation));
1520 
1521  using FetchInfo0 = InvocationToFetch<ThreadIndicesType, Invocation, 0>;
1522  using ReturnFetchType = typename FetchInfo0::type;
1523  ReturnFetchType returnFetch;
1524  // If you got a compile error on the following line, it probably means that
1525  // the operator() of a worklet does not match the definition expected. One
1526  // common problem is that the operator() method must be declared const. Check
1527  // to make sure the "const" keyword is after parameters. Another common
1528  // problem is that the type of one or more parameters is incompatible with
1529  // the actual type that VTK-m creates in the execution environment. Make sure
1530  // that the types of the worklet operator() parameters match those in the
1531  // ExecutionSignature. The compiler error might help you narrow down which
1532  // parameter is wrong and the types that did not match.
1533  auto r = worklet(p1, p2, p3, p4, p5, p6, p7, p8, p9);
1534 
1535  fetch1.Store(threadIndices, FetchInfo1::GetParameter(invocation), p1);
1536  fetch2.Store(threadIndices, FetchInfo2::GetParameter(invocation), p2);
1537  fetch3.Store(threadIndices, FetchInfo3::GetParameter(invocation), p3);
1538  fetch4.Store(threadIndices, FetchInfo4::GetParameter(invocation), p4);
1539  fetch5.Store(threadIndices, FetchInfo5::GetParameter(invocation), p5);
1540  fetch6.Store(threadIndices, FetchInfo6::GetParameter(invocation), p6);
1541  fetch7.Store(threadIndices, FetchInfo7::GetParameter(invocation), p7);
1542  fetch8.Store(threadIndices, FetchInfo8::GetParameter(invocation), p8);
1543  fetch9.Store(threadIndices, FetchInfo9::GetParameter(invocation), p9);
1544 
1545  returnFetch.Store(threadIndices, FetchInfo0::GetParameter(invocation), r);
1546 }
1547 
1548 template <typename WorkletType,
1549  typename ParameterInterface,
1550  typename ControlInterface,
1551  vtkm::IdComponent InputDomainIndex,
1552  typename OutputToInputMapType,
1553  typename VisitArrayType,
1554  typename ThreadToOutputMapType,
1555  typename DeviceAdapterTag,
1556  typename ThreadIndicesType,
1557  typename P1,
1558  typename P2,
1559  typename P3,
1560  typename P4,
1561  typename P5,
1562  typename P6,
1563  typename P7,
1564  typename P8,
1565  typename P9>
1566 VTKM_EXEC void DoWorkletInvokeFunctor(
1567  const WorkletType& worklet,
1568  const vtkm::internal::Invocation<ParameterInterface,
1569  ControlInterface,
1570  vtkm::internal::FunctionInterface<void(P1, P2, P3, P4, P5, P6, P7, P8, P9)>,
1571  InputDomainIndex,
1572  OutputToInputMapType,
1573  VisitArrayType,
1574  ThreadToOutputMapType,
1575  DeviceAdapterTag>& invocation,
1576  const ThreadIndicesType& threadIndices)
1577 {
1578  using Invocation =
1579  vtkm::internal::Invocation<ParameterInterface,
1580  ControlInterface,
1581  vtkm::internal::FunctionInterface<void(P1, P2, P3, P4, P5, P6, P7, P8, P9)>,
1582  InputDomainIndex,
1583  OutputToInputMapType,
1584  VisitArrayType,
1585  ThreadToOutputMapType,
1586  DeviceAdapterTag>;
1587 
1588  using FetchInfo1 = InvocationToFetch<ThreadIndicesType, Invocation, 1>;
1589  using FetchType1 = typename FetchInfo1::type;
1590  FetchType1 fetch1;
1591  auto p1 =
1592  fetch1.Load(threadIndices, FetchInfo1::GetParameter(invocation));
1593 
1594  using FetchInfo2 = InvocationToFetch<ThreadIndicesType, Invocation, 2>;
1595  using FetchType2 = typename FetchInfo2::type;
1596  FetchType2 fetch2;
1597  auto p2 =
1598  fetch2.Load(threadIndices, FetchInfo2::GetParameter(invocation));
1599 
1600  using FetchInfo3 = InvocationToFetch<ThreadIndicesType, Invocation, 3>;
1601  using FetchType3 = typename FetchInfo3::type;
1602  FetchType3 fetch3;
1603  auto p3 =
1604  fetch3.Load(threadIndices, FetchInfo3::GetParameter(invocation));
1605 
1606  using FetchInfo4 = InvocationToFetch<ThreadIndicesType, Invocation, 4>;
1607  using FetchType4 = typename FetchInfo4::type;
1608  FetchType4 fetch4;
1609  auto p4 =
1610  fetch4.Load(threadIndices, FetchInfo4::GetParameter(invocation));
1611 
1612  using FetchInfo5 = InvocationToFetch<ThreadIndicesType, Invocation, 5>;
1613  using FetchType5 = typename FetchInfo5::type;
1614  FetchType5 fetch5;
1615  auto p5 =
1616  fetch5.Load(threadIndices, FetchInfo5::GetParameter(invocation));
1617 
1618  using FetchInfo6 = InvocationToFetch<ThreadIndicesType, Invocation, 6>;
1619  using FetchType6 = typename FetchInfo6::type;
1620  FetchType6 fetch6;
1621  auto p6 =
1622  fetch6.Load(threadIndices, FetchInfo6::GetParameter(invocation));
1623 
1624  using FetchInfo7 = InvocationToFetch<ThreadIndicesType, Invocation, 7>;
1625  using FetchType7 = typename FetchInfo7::type;
1626  FetchType7 fetch7;
1627  auto p7 =
1628  fetch7.Load(threadIndices, FetchInfo7::GetParameter(invocation));
1629 
1630  using FetchInfo8 = InvocationToFetch<ThreadIndicesType, Invocation, 8>;
1631  using FetchType8 = typename FetchInfo8::type;
1632  FetchType8 fetch8;
1633  auto p8 =
1634  fetch8.Load(threadIndices, FetchInfo8::GetParameter(invocation));
1635 
1636  using FetchInfo9 = InvocationToFetch<ThreadIndicesType, Invocation, 9>;
1637  using FetchType9 = typename FetchInfo9::type;
1638  FetchType9 fetch9;
1639  auto p9 =
1640  fetch9.Load(threadIndices, FetchInfo9::GetParameter(invocation));
1641 
1642  // If you got a compile error on the following line, it probably means that
1643  // the operator() of a worklet does not match the definition expected. One
1644  // common problem is that the operator() method must be declared const. Check
1645  // to make sure the "const" keyword is after parameters. Another common
1646  // problem is that the type of one or more parameters is incompatible with
1647  // the actual type that VTK-m creates in the execution environment. Make sure
1648  // that the types of the worklet operator() parameters match those in the
1649  // ExecutionSignature. The compiler error might help you narrow down which
1650  // parameter is wrong and the types that did not match.
1651  worklet(p1, p2, p3, p4, p5, p6, p7, p8, p9);
1652 
1653  fetch1.Store(threadIndices, FetchInfo1::GetParameter(invocation), p1);
1654  fetch2.Store(threadIndices, FetchInfo2::GetParameter(invocation), p2);
1655  fetch3.Store(threadIndices, FetchInfo3::GetParameter(invocation), p3);
1656  fetch4.Store(threadIndices, FetchInfo4::GetParameter(invocation), p4);
1657  fetch5.Store(threadIndices, FetchInfo5::GetParameter(invocation), p5);
1658  fetch6.Store(threadIndices, FetchInfo6::GetParameter(invocation), p6);
1659  fetch7.Store(threadIndices, FetchInfo7::GetParameter(invocation), p7);
1660  fetch8.Store(threadIndices, FetchInfo8::GetParameter(invocation), p8);
1661  fetch9.Store(threadIndices, FetchInfo9::GetParameter(invocation), p9);
1662 }
1663 
1664 template <typename WorkletType,
1665  typename ParameterInterface,
1666  typename ControlInterface,
1667  vtkm::IdComponent InputDomainIndex,
1668  typename OutputToInputMapType,
1669  typename VisitArrayType,
1670  typename ThreadToOutputMapType,
1671  typename DeviceAdapterTag,
1672  typename ThreadIndicesType,
1673  typename R,
1674  typename P1,
1675  typename P2,
1676  typename P3,
1677  typename P4,
1678  typename P5,
1679  typename P6,
1680  typename P7,
1681  typename P8,
1682  typename P9,
1683  typename P10>
1684 VTKM_EXEC void DoWorkletInvokeFunctor(
1685  const WorkletType& worklet,
1686  const vtkm::internal::Invocation<ParameterInterface,
1687  ControlInterface,
1688  vtkm::internal::FunctionInterface<R(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10)>,
1689  InputDomainIndex,
1690  OutputToInputMapType,
1691  VisitArrayType,
1692  ThreadToOutputMapType,
1693  DeviceAdapterTag>& invocation,
1694  const ThreadIndicesType& threadIndices)
1695 {
1696  using Invocation = vtkm::internal::Invocation<ParameterInterface,
1697  ControlInterface,
1698  vtkm::internal::FunctionInterface<R(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10)>,
1699  InputDomainIndex,
1700  OutputToInputMapType,
1701  VisitArrayType,
1702  ThreadToOutputMapType,
1703  DeviceAdapterTag>;
1704 
1705  using FetchInfo1 = InvocationToFetch<ThreadIndicesType, Invocation, 1>;
1706  using FetchType1 = typename FetchInfo1::type;
1707  FetchType1 fetch1;
1708  auto p1 =
1709  fetch1.Load(threadIndices, FetchInfo1::GetParameter(invocation));
1710 
1711  using FetchInfo2 = InvocationToFetch<ThreadIndicesType, Invocation, 2>;
1712  using FetchType2 = typename FetchInfo2::type;
1713  FetchType2 fetch2;
1714  auto p2 =
1715  fetch2.Load(threadIndices, FetchInfo2::GetParameter(invocation));
1716 
1717  using FetchInfo3 = InvocationToFetch<ThreadIndicesType, Invocation, 3>;
1718  using FetchType3 = typename FetchInfo3::type;
1719  FetchType3 fetch3;
1720  auto p3 =
1721  fetch3.Load(threadIndices, FetchInfo3::GetParameter(invocation));
1722 
1723  using FetchInfo4 = InvocationToFetch<ThreadIndicesType, Invocation, 4>;
1724  using FetchType4 = typename FetchInfo4::type;
1725  FetchType4 fetch4;
1726  auto p4 =
1727  fetch4.Load(threadIndices, FetchInfo4::GetParameter(invocation));
1728 
1729  using FetchInfo5 = InvocationToFetch<ThreadIndicesType, Invocation, 5>;
1730  using FetchType5 = typename FetchInfo5::type;
1731  FetchType5 fetch5;
1732  auto p5 =
1733  fetch5.Load(threadIndices, FetchInfo5::GetParameter(invocation));
1734 
1735  using FetchInfo6 = InvocationToFetch<ThreadIndicesType, Invocation, 6>;
1736  using FetchType6 = typename FetchInfo6::type;
1737  FetchType6 fetch6;
1738  auto p6 =
1739  fetch6.Load(threadIndices, FetchInfo6::GetParameter(invocation));
1740 
1741  using FetchInfo7 = InvocationToFetch<ThreadIndicesType, Invocation, 7>;
1742  using FetchType7 = typename FetchInfo7::type;
1743  FetchType7 fetch7;
1744  auto p7 =
1745  fetch7.Load(threadIndices, FetchInfo7::GetParameter(invocation));
1746 
1747  using FetchInfo8 = InvocationToFetch<ThreadIndicesType, Invocation, 8>;
1748  using FetchType8 = typename FetchInfo8::type;
1749  FetchType8 fetch8;
1750  auto p8 =
1751  fetch8.Load(threadIndices, FetchInfo8::GetParameter(invocation));
1752 
1753  using FetchInfo9 = InvocationToFetch<ThreadIndicesType, Invocation, 9>;
1754  using FetchType9 = typename FetchInfo9::type;
1755  FetchType9 fetch9;
1756  auto p9 =
1757  fetch9.Load(threadIndices, FetchInfo9::GetParameter(invocation));
1758 
1759  using FetchInfo10 = InvocationToFetch<ThreadIndicesType, Invocation, 10>;
1760  using FetchType10 = typename FetchInfo10::type;
1761  FetchType10 fetch10;
1762  auto p10 =
1763  fetch10.Load(threadIndices, FetchInfo10::GetParameter(invocation));
1764 
1765  using FetchInfo0 = InvocationToFetch<ThreadIndicesType, Invocation, 0>;
1766  using ReturnFetchType = typename FetchInfo0::type;
1767  ReturnFetchType returnFetch;
1768  // If you got a compile error on the following line, it probably means that
1769  // the operator() of a worklet does not match the definition expected. One
1770  // common problem is that the operator() method must be declared const. Check
1771  // to make sure the "const" keyword is after parameters. Another common
1772  // problem is that the type of one or more parameters is incompatible with
1773  // the actual type that VTK-m creates in the execution environment. Make sure
1774  // that the types of the worklet operator() parameters match those in the
1775  // ExecutionSignature. The compiler error might help you narrow down which
1776  // parameter is wrong and the types that did not match.
1777  auto r = worklet(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10);
1778 
1779  fetch1.Store(threadIndices, FetchInfo1::GetParameter(invocation), p1);
1780  fetch2.Store(threadIndices, FetchInfo2::GetParameter(invocation), p2);
1781  fetch3.Store(threadIndices, FetchInfo3::GetParameter(invocation), p3);
1782  fetch4.Store(threadIndices, FetchInfo4::GetParameter(invocation), p4);
1783  fetch5.Store(threadIndices, FetchInfo5::GetParameter(invocation), p5);
1784  fetch6.Store(threadIndices, FetchInfo6::GetParameter(invocation), p6);
1785  fetch7.Store(threadIndices, FetchInfo7::GetParameter(invocation), p7);
1786  fetch8.Store(threadIndices, FetchInfo8::GetParameter(invocation), p8);
1787  fetch9.Store(threadIndices, FetchInfo9::GetParameter(invocation), p9);
1788  fetch10.Store(threadIndices, FetchInfo10::GetParameter(invocation), p10);
1789 
1790  returnFetch.Store(threadIndices, FetchInfo0::GetParameter(invocation), r);
1791 }
1792 
1793 template <typename WorkletType,
1794  typename ParameterInterface,
1795  typename ControlInterface,
1796  vtkm::IdComponent InputDomainIndex,
1797  typename OutputToInputMapType,
1798  typename VisitArrayType,
1799  typename ThreadToOutputMapType,
1800  typename DeviceAdapterTag,
1801  typename ThreadIndicesType,
1802  typename P1,
1803  typename P2,
1804  typename P3,
1805  typename P4,
1806  typename P5,
1807  typename P6,
1808  typename P7,
1809  typename P8,
1810  typename P9,
1811  typename P10>
1812 VTKM_EXEC void DoWorkletInvokeFunctor(
1813  const WorkletType& worklet,
1814  const vtkm::internal::Invocation<ParameterInterface,
1815  ControlInterface,
1816  vtkm::internal::FunctionInterface<void(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10)>,
1817  InputDomainIndex,
1818  OutputToInputMapType,
1819  VisitArrayType,
1820  ThreadToOutputMapType,
1821  DeviceAdapterTag>& invocation,
1822  const ThreadIndicesType& threadIndices)
1823 {
1824  using Invocation =
1825  vtkm::internal::Invocation<ParameterInterface,
1826  ControlInterface,
1827  vtkm::internal::FunctionInterface<void(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10)>,
1828  InputDomainIndex,
1829  OutputToInputMapType,
1830  VisitArrayType,
1831  ThreadToOutputMapType,
1832  DeviceAdapterTag>;
1833 
1834  using FetchInfo1 = InvocationToFetch<ThreadIndicesType, Invocation, 1>;
1835  using FetchType1 = typename FetchInfo1::type;
1836  FetchType1 fetch1;
1837  auto p1 =
1838  fetch1.Load(threadIndices, FetchInfo1::GetParameter(invocation));
1839 
1840  using FetchInfo2 = InvocationToFetch<ThreadIndicesType, Invocation, 2>;
1841  using FetchType2 = typename FetchInfo2::type;
1842  FetchType2 fetch2;
1843  auto p2 =
1844  fetch2.Load(threadIndices, FetchInfo2::GetParameter(invocation));
1845 
1846  using FetchInfo3 = InvocationToFetch<ThreadIndicesType, Invocation, 3>;
1847  using FetchType3 = typename FetchInfo3::type;
1848  FetchType3 fetch3;
1849  auto p3 =
1850  fetch3.Load(threadIndices, FetchInfo3::GetParameter(invocation));
1851 
1852  using FetchInfo4 = InvocationToFetch<ThreadIndicesType, Invocation, 4>;
1853  using FetchType4 = typename FetchInfo4::type;
1854  FetchType4 fetch4;
1855  auto p4 =
1856  fetch4.Load(threadIndices, FetchInfo4::GetParameter(invocation));
1857 
1858  using FetchInfo5 = InvocationToFetch<ThreadIndicesType, Invocation, 5>;
1859  using FetchType5 = typename FetchInfo5::type;
1860  FetchType5 fetch5;
1861  auto p5 =
1862  fetch5.Load(threadIndices, FetchInfo5::GetParameter(invocation));
1863 
1864  using FetchInfo6 = InvocationToFetch<ThreadIndicesType, Invocation, 6>;
1865  using FetchType6 = typename FetchInfo6::type;
1866  FetchType6 fetch6;
1867  auto p6 =
1868  fetch6.Load(threadIndices, FetchInfo6::GetParameter(invocation));
1869 
1870  using FetchInfo7 = InvocationToFetch<ThreadIndicesType, Invocation, 7>;
1871  using FetchType7 = typename FetchInfo7::type;
1872  FetchType7 fetch7;
1873  auto p7 =
1874  fetch7.Load(threadIndices, FetchInfo7::GetParameter(invocation));
1875 
1876  using FetchInfo8 = InvocationToFetch<ThreadIndicesType, Invocation, 8>;
1877  using FetchType8 = typename FetchInfo8::type;
1878  FetchType8 fetch8;
1879  auto p8 =
1880  fetch8.Load(threadIndices, FetchInfo8::GetParameter(invocation));
1881 
1882  using FetchInfo9 = InvocationToFetch<ThreadIndicesType, Invocation, 9>;
1883  using FetchType9 = typename FetchInfo9::type;
1884  FetchType9 fetch9;
1885  auto p9 =
1886  fetch9.Load(threadIndices, FetchInfo9::GetParameter(invocation));
1887 
1888  using FetchInfo10 = InvocationToFetch<ThreadIndicesType, Invocation, 10>;
1889  using FetchType10 = typename FetchInfo10::type;
1890  FetchType10 fetch10;
1891  auto p10 =
1892  fetch10.Load(threadIndices, FetchInfo10::GetParameter(invocation));
1893 
1894  // If you got a compile error on the following line, it probably means that
1895  // the operator() of a worklet does not match the definition expected. One
1896  // common problem is that the operator() method must be declared const. Check
1897  // to make sure the "const" keyword is after parameters. Another common
1898  // problem is that the type of one or more parameters is incompatible with
1899  // the actual type that VTK-m creates in the execution environment. Make sure
1900  // that the types of the worklet operator() parameters match those in the
1901  // ExecutionSignature. The compiler error might help you narrow down which
1902  // parameter is wrong and the types that did not match.
1903  worklet(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10);
1904 
1905  fetch1.Store(threadIndices, FetchInfo1::GetParameter(invocation), p1);
1906  fetch2.Store(threadIndices, FetchInfo2::GetParameter(invocation), p2);
1907  fetch3.Store(threadIndices, FetchInfo3::GetParameter(invocation), p3);
1908  fetch4.Store(threadIndices, FetchInfo4::GetParameter(invocation), p4);
1909  fetch5.Store(threadIndices, FetchInfo5::GetParameter(invocation), p5);
1910  fetch6.Store(threadIndices, FetchInfo6::GetParameter(invocation), p6);
1911  fetch7.Store(threadIndices, FetchInfo7::GetParameter(invocation), p7);
1912  fetch8.Store(threadIndices, FetchInfo8::GetParameter(invocation), p8);
1913  fetch9.Store(threadIndices, FetchInfo9::GetParameter(invocation), p9);
1914  fetch10.Store(threadIndices, FetchInfo10::GetParameter(invocation), p10);
1915 }
1916 
1917 template <typename WorkletType,
1918  typename ParameterInterface,
1919  typename ControlInterface,
1920  vtkm::IdComponent InputDomainIndex,
1921  typename OutputToInputMapType,
1922  typename VisitArrayType,
1923  typename ThreadToOutputMapType,
1924  typename DeviceAdapterTag,
1925  typename ThreadIndicesType,
1926  typename R,
1927  typename P1,
1928  typename P2,
1929  typename P3,
1930  typename P4,
1931  typename P5,
1932  typename P6,
1933  typename P7,
1934  typename P8,
1935  typename P9,
1936  typename P10,
1937  typename P11>
1938 VTKM_EXEC void DoWorkletInvokeFunctor(
1939  const WorkletType& worklet,
1940  const vtkm::internal::Invocation<ParameterInterface,
1941  ControlInterface,
1942  vtkm::internal::FunctionInterface<R(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11)>,
1943  InputDomainIndex,
1944  OutputToInputMapType,
1945  VisitArrayType,
1946  ThreadToOutputMapType,
1947  DeviceAdapterTag>& invocation,
1948  const ThreadIndicesType& threadIndices)
1949 {
1950  using Invocation = vtkm::internal::Invocation<ParameterInterface,
1951  ControlInterface,
1952  vtkm::internal::FunctionInterface<R(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11)>,
1953  InputDomainIndex,
1954  OutputToInputMapType,
1955  VisitArrayType,
1956  ThreadToOutputMapType,
1957  DeviceAdapterTag>;
1958 
1959  using FetchInfo1 = InvocationToFetch<ThreadIndicesType, Invocation, 1>;
1960  using FetchType1 = typename FetchInfo1::type;
1961  FetchType1 fetch1;
1962  auto p1 =
1963  fetch1.Load(threadIndices, FetchInfo1::GetParameter(invocation));
1964 
1965  using FetchInfo2 = InvocationToFetch<ThreadIndicesType, Invocation, 2>;
1966  using FetchType2 = typename FetchInfo2::type;
1967  FetchType2 fetch2;
1968  auto p2 =
1969  fetch2.Load(threadIndices, FetchInfo2::GetParameter(invocation));
1970 
1971  using FetchInfo3 = InvocationToFetch<ThreadIndicesType, Invocation, 3>;
1972  using FetchType3 = typename FetchInfo3::type;
1973  FetchType3 fetch3;
1974  auto p3 =
1975  fetch3.Load(threadIndices, FetchInfo3::GetParameter(invocation));
1976 
1977  using FetchInfo4 = InvocationToFetch<ThreadIndicesType, Invocation, 4>;
1978  using FetchType4 = typename FetchInfo4::type;
1979  FetchType4 fetch4;
1980  auto p4 =
1981  fetch4.Load(threadIndices, FetchInfo4::GetParameter(invocation));
1982 
1983  using FetchInfo5 = InvocationToFetch<ThreadIndicesType, Invocation, 5>;
1984  using FetchType5 = typename FetchInfo5::type;
1985  FetchType5 fetch5;
1986  auto p5 =
1987  fetch5.Load(threadIndices, FetchInfo5::GetParameter(invocation));
1988 
1989  using FetchInfo6 = InvocationToFetch<ThreadIndicesType, Invocation, 6>;
1990  using FetchType6 = typename FetchInfo6::type;
1991  FetchType6 fetch6;
1992  auto p6 =
1993  fetch6.Load(threadIndices, FetchInfo6::GetParameter(invocation));
1994 
1995  using FetchInfo7 = InvocationToFetch<ThreadIndicesType, Invocation, 7>;
1996  using FetchType7 = typename FetchInfo7::type;
1997  FetchType7 fetch7;
1998  auto p7 =
1999  fetch7.Load(threadIndices, FetchInfo7::GetParameter(invocation));
2000 
2001  using FetchInfo8 = InvocationToFetch<ThreadIndicesType, Invocation, 8>;
2002  using FetchType8 = typename FetchInfo8::type;
2003  FetchType8 fetch8;
2004  auto p8 =
2005  fetch8.Load(threadIndices, FetchInfo8::GetParameter(invocation));
2006 
2007  using FetchInfo9 = InvocationToFetch<ThreadIndicesType, Invocation, 9>;
2008  using FetchType9 = typename FetchInfo9::type;
2009  FetchType9 fetch9;
2010  auto p9 =
2011  fetch9.Load(threadIndices, FetchInfo9::GetParameter(invocation));
2012 
2013  using FetchInfo10 = InvocationToFetch<ThreadIndicesType, Invocation, 10>;
2014  using FetchType10 = typename FetchInfo10::type;
2015  FetchType10 fetch10;
2016  auto p10 =
2017  fetch10.Load(threadIndices, FetchInfo10::GetParameter(invocation));
2018 
2019  using FetchInfo11 = InvocationToFetch<ThreadIndicesType, Invocation, 11>;
2020  using FetchType11 = typename FetchInfo11::type;
2021  FetchType11 fetch11;
2022  auto p11 =
2023  fetch11.Load(threadIndices, FetchInfo11::GetParameter(invocation));
2024 
2025  using FetchInfo0 = InvocationToFetch<ThreadIndicesType, Invocation, 0>;
2026  using ReturnFetchType = typename FetchInfo0::type;
2027  ReturnFetchType returnFetch;
2028  // If you got a compile error on the following line, it probably means that
2029  // the operator() of a worklet does not match the definition expected. One
2030  // common problem is that the operator() method must be declared const. Check
2031  // to make sure the "const" keyword is after parameters. Another common
2032  // problem is that the type of one or more parameters is incompatible with
2033  // the actual type that VTK-m creates in the execution environment. Make sure
2034  // that the types of the worklet operator() parameters match those in the
2035  // ExecutionSignature. The compiler error might help you narrow down which
2036  // parameter is wrong and the types that did not match.
2037  auto r = worklet(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11);
2038 
2039  fetch1.Store(threadIndices, FetchInfo1::GetParameter(invocation), p1);
2040  fetch2.Store(threadIndices, FetchInfo2::GetParameter(invocation), p2);
2041  fetch3.Store(threadIndices, FetchInfo3::GetParameter(invocation), p3);
2042  fetch4.Store(threadIndices, FetchInfo4::GetParameter(invocation), p4);
2043  fetch5.Store(threadIndices, FetchInfo5::GetParameter(invocation), p5);
2044  fetch6.Store(threadIndices, FetchInfo6::GetParameter(invocation), p6);
2045  fetch7.Store(threadIndices, FetchInfo7::GetParameter(invocation), p7);
2046  fetch8.Store(threadIndices, FetchInfo8::GetParameter(invocation), p8);
2047  fetch9.Store(threadIndices, FetchInfo9::GetParameter(invocation), p9);
2048  fetch10.Store(threadIndices, FetchInfo10::GetParameter(invocation), p10);
2049  fetch11.Store(threadIndices, FetchInfo11::GetParameter(invocation), p11);
2050 
2051  returnFetch.Store(threadIndices, FetchInfo0::GetParameter(invocation), r);
2052 }
2053 
2054 template <typename WorkletType,
2055  typename ParameterInterface,
2056  typename ControlInterface,
2057  vtkm::IdComponent InputDomainIndex,
2058  typename OutputToInputMapType,
2059  typename VisitArrayType,
2060  typename ThreadToOutputMapType,
2061  typename DeviceAdapterTag,
2062  typename ThreadIndicesType,
2063  typename P1,
2064  typename P2,
2065  typename P3,
2066  typename P4,
2067  typename P5,
2068  typename P6,
2069  typename P7,
2070  typename P8,
2071  typename P9,
2072  typename P10,
2073  typename P11>
2074 VTKM_EXEC void DoWorkletInvokeFunctor(
2075  const WorkletType& worklet,
2076  const vtkm::internal::Invocation<ParameterInterface,
2077  ControlInterface,
2078  vtkm::internal::FunctionInterface<void(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11)>,
2079  InputDomainIndex,
2080  OutputToInputMapType,
2081  VisitArrayType,
2082  ThreadToOutputMapType,
2083  DeviceAdapterTag>& invocation,
2084  const ThreadIndicesType& threadIndices)
2085 {
2086  using Invocation =
2087  vtkm::internal::Invocation<ParameterInterface,
2088  ControlInterface,
2089  vtkm::internal::FunctionInterface<void(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11)>,
2090  InputDomainIndex,
2091  OutputToInputMapType,
2092  VisitArrayType,
2093  ThreadToOutputMapType,
2094  DeviceAdapterTag>;
2095 
2096  using FetchInfo1 = InvocationToFetch<ThreadIndicesType, Invocation, 1>;
2097  using FetchType1 = typename FetchInfo1::type;
2098  FetchType1 fetch1;
2099  auto p1 =
2100  fetch1.Load(threadIndices, FetchInfo1::GetParameter(invocation));
2101 
2102  using FetchInfo2 = InvocationToFetch<ThreadIndicesType, Invocation, 2>;
2103  using FetchType2 = typename FetchInfo2::type;
2104  FetchType2 fetch2;
2105  auto p2 =
2106  fetch2.Load(threadIndices, FetchInfo2::GetParameter(invocation));
2107 
2108  using FetchInfo3 = InvocationToFetch<ThreadIndicesType, Invocation, 3>;
2109  using FetchType3 = typename FetchInfo3::type;
2110  FetchType3 fetch3;
2111  auto p3 =
2112  fetch3.Load(threadIndices, FetchInfo3::GetParameter(invocation));
2113 
2114  using FetchInfo4 = InvocationToFetch<ThreadIndicesType, Invocation, 4>;
2115  using FetchType4 = typename FetchInfo4::type;
2116  FetchType4 fetch4;
2117  auto p4 =
2118  fetch4.Load(threadIndices, FetchInfo4::GetParameter(invocation));
2119 
2120  using FetchInfo5 = InvocationToFetch<ThreadIndicesType, Invocation, 5>;
2121  using FetchType5 = typename FetchInfo5::type;
2122  FetchType5 fetch5;
2123  auto p5 =
2124  fetch5.Load(threadIndices, FetchInfo5::GetParameter(invocation));
2125 
2126  using FetchInfo6 = InvocationToFetch<ThreadIndicesType, Invocation, 6>;
2127  using FetchType6 = typename FetchInfo6::type;
2128  FetchType6 fetch6;
2129  auto p6 =
2130  fetch6.Load(threadIndices, FetchInfo6::GetParameter(invocation));
2131 
2132  using FetchInfo7 = InvocationToFetch<ThreadIndicesType, Invocation, 7>;
2133  using FetchType7 = typename FetchInfo7::type;
2134  FetchType7 fetch7;
2135  auto p7 =
2136  fetch7.Load(threadIndices, FetchInfo7::GetParameter(invocation));
2137 
2138  using FetchInfo8 = InvocationToFetch<ThreadIndicesType, Invocation, 8>;
2139  using FetchType8 = typename FetchInfo8::type;
2140  FetchType8 fetch8;
2141  auto p8 =
2142  fetch8.Load(threadIndices, FetchInfo8::GetParameter(invocation));
2143 
2144  using FetchInfo9 = InvocationToFetch<ThreadIndicesType, Invocation, 9>;
2145  using FetchType9 = typename FetchInfo9::type;
2146  FetchType9 fetch9;
2147  auto p9 =
2148  fetch9.Load(threadIndices, FetchInfo9::GetParameter(invocation));
2149 
2150  using FetchInfo10 = InvocationToFetch<ThreadIndicesType, Invocation, 10>;
2151  using FetchType10 = typename FetchInfo10::type;
2152  FetchType10 fetch10;
2153  auto p10 =
2154  fetch10.Load(threadIndices, FetchInfo10::GetParameter(invocation));
2155 
2156  using FetchInfo11 = InvocationToFetch<ThreadIndicesType, Invocation, 11>;
2157  using FetchType11 = typename FetchInfo11::type;
2158  FetchType11 fetch11;
2159  auto p11 =
2160  fetch11.Load(threadIndices, FetchInfo11::GetParameter(invocation));
2161 
2162  // If you got a compile error on the following line, it probably means that
2163  // the operator() of a worklet does not match the definition expected. One
2164  // common problem is that the operator() method must be declared const. Check
2165  // to make sure the "const" keyword is after parameters. Another common
2166  // problem is that the type of one or more parameters is incompatible with
2167  // the actual type that VTK-m creates in the execution environment. Make sure
2168  // that the types of the worklet operator() parameters match those in the
2169  // ExecutionSignature. The compiler error might help you narrow down which
2170  // parameter is wrong and the types that did not match.
2171  worklet(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11);
2172 
2173  fetch1.Store(threadIndices, FetchInfo1::GetParameter(invocation), p1);
2174  fetch2.Store(threadIndices, FetchInfo2::GetParameter(invocation), p2);
2175  fetch3.Store(threadIndices, FetchInfo3::GetParameter(invocation), p3);
2176  fetch4.Store(threadIndices, FetchInfo4::GetParameter(invocation), p4);
2177  fetch5.Store(threadIndices, FetchInfo5::GetParameter(invocation), p5);
2178  fetch6.Store(threadIndices, FetchInfo6::GetParameter(invocation), p6);
2179  fetch7.Store(threadIndices, FetchInfo7::GetParameter(invocation), p7);
2180  fetch8.Store(threadIndices, FetchInfo8::GetParameter(invocation), p8);
2181  fetch9.Store(threadIndices, FetchInfo9::GetParameter(invocation), p9);
2182  fetch10.Store(threadIndices, FetchInfo10::GetParameter(invocation), p10);
2183  fetch11.Store(threadIndices, FetchInfo11::GetParameter(invocation), p11);
2184 }
2185 
2186 template <typename WorkletType,
2187  typename ParameterInterface,
2188  typename ControlInterface,
2189  vtkm::IdComponent InputDomainIndex,
2190  typename OutputToInputMapType,
2191  typename VisitArrayType,
2192  typename ThreadToOutputMapType,
2193  typename DeviceAdapterTag,
2194  typename ThreadIndicesType,
2195  typename R,
2196  typename P1,
2197  typename P2,
2198  typename P3,
2199  typename P4,
2200  typename P5,
2201  typename P6,
2202  typename P7,
2203  typename P8,
2204  typename P9,
2205  typename P10,
2206  typename P11,
2207  typename P12>
2208 VTKM_EXEC void DoWorkletInvokeFunctor(
2209  const WorkletType& worklet,
2210  const vtkm::internal::Invocation<ParameterInterface,
2211  ControlInterface,
2212  vtkm::internal::FunctionInterface<R(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12)>,
2213  InputDomainIndex,
2214  OutputToInputMapType,
2215  VisitArrayType,
2216  ThreadToOutputMapType,
2217  DeviceAdapterTag>& invocation,
2218  const ThreadIndicesType& threadIndices)
2219 {
2220  using Invocation = vtkm::internal::Invocation<ParameterInterface,
2221  ControlInterface,
2222  vtkm::internal::FunctionInterface<R(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12)>,
2223  InputDomainIndex,
2224  OutputToInputMapType,
2225  VisitArrayType,
2226  ThreadToOutputMapType,
2227  DeviceAdapterTag>;
2228 
2229  using FetchInfo1 = InvocationToFetch<ThreadIndicesType, Invocation, 1>;
2230  using FetchType1 = typename FetchInfo1::type;
2231  FetchType1 fetch1;
2232  auto p1 =
2233  fetch1.Load(threadIndices, FetchInfo1::GetParameter(invocation));
2234 
2235  using FetchInfo2 = InvocationToFetch<ThreadIndicesType, Invocation, 2>;
2236  using FetchType2 = typename FetchInfo2::type;
2237  FetchType2 fetch2;
2238  auto p2 =
2239  fetch2.Load(threadIndices, FetchInfo2::GetParameter(invocation));
2240 
2241  using FetchInfo3 = InvocationToFetch<ThreadIndicesType, Invocation, 3>;
2242  using FetchType3 = typename FetchInfo3::type;
2243  FetchType3 fetch3;
2244  auto p3 =
2245  fetch3.Load(threadIndices, FetchInfo3::GetParameter(invocation));
2246 
2247  using FetchInfo4 = InvocationToFetch<ThreadIndicesType, Invocation, 4>;
2248  using FetchType4 = typename FetchInfo4::type;
2249  FetchType4 fetch4;
2250  auto p4 =
2251  fetch4.Load(threadIndices, FetchInfo4::GetParameter(invocation));
2252 
2253  using FetchInfo5 = InvocationToFetch<ThreadIndicesType, Invocation, 5>;
2254  using FetchType5 = typename FetchInfo5::type;
2255  FetchType5 fetch5;
2256  auto p5 =
2257  fetch5.Load(threadIndices, FetchInfo5::GetParameter(invocation));
2258 
2259  using FetchInfo6 = InvocationToFetch<ThreadIndicesType, Invocation, 6>;
2260  using FetchType6 = typename FetchInfo6::type;
2261  FetchType6 fetch6;
2262  auto p6 =
2263  fetch6.Load(threadIndices, FetchInfo6::GetParameter(invocation));
2264 
2265  using FetchInfo7 = InvocationToFetch<ThreadIndicesType, Invocation, 7>;
2266  using FetchType7 = typename FetchInfo7::type;
2267  FetchType7 fetch7;
2268  auto p7 =
2269  fetch7.Load(threadIndices, FetchInfo7::GetParameter(invocation));
2270 
2271  using FetchInfo8 = InvocationToFetch<ThreadIndicesType, Invocation, 8>;
2272  using FetchType8 = typename FetchInfo8::type;
2273  FetchType8 fetch8;
2274  auto p8 =
2275  fetch8.Load(threadIndices, FetchInfo8::GetParameter(invocation));
2276 
2277  using FetchInfo9 = InvocationToFetch<ThreadIndicesType, Invocation, 9>;
2278  using FetchType9 = typename FetchInfo9::type;
2279  FetchType9 fetch9;
2280  auto p9 =
2281  fetch9.Load(threadIndices, FetchInfo9::GetParameter(invocation));
2282 
2283  using FetchInfo10 = InvocationToFetch<ThreadIndicesType, Invocation, 10>;
2284  using FetchType10 = typename FetchInfo10::type;
2285  FetchType10 fetch10;
2286  auto p10 =
2287  fetch10.Load(threadIndices, FetchInfo10::GetParameter(invocation));
2288 
2289  using FetchInfo11 = InvocationToFetch<ThreadIndicesType, Invocation, 11>;
2290  using FetchType11 = typename FetchInfo11::type;
2291  FetchType11 fetch11;
2292  auto p11 =
2293  fetch11.Load(threadIndices, FetchInfo11::GetParameter(invocation));
2294 
2295  using FetchInfo12 = InvocationToFetch<ThreadIndicesType, Invocation, 12>;
2296  using FetchType12 = typename FetchInfo12::type;
2297  FetchType12 fetch12;
2298  auto p12 =
2299  fetch12.Load(threadIndices, FetchInfo12::GetParameter(invocation));
2300 
2301  using FetchInfo0 = InvocationToFetch<ThreadIndicesType, Invocation, 0>;
2302  using ReturnFetchType = typename FetchInfo0::type;
2303  ReturnFetchType returnFetch;
2304  // If you got a compile error on the following line, it probably means that
2305  // the operator() of a worklet does not match the definition expected. One
2306  // common problem is that the operator() method must be declared const. Check
2307  // to make sure the "const" keyword is after parameters. Another common
2308  // problem is that the type of one or more parameters is incompatible with
2309  // the actual type that VTK-m creates in the execution environment. Make sure
2310  // that the types of the worklet operator() parameters match those in the
2311  // ExecutionSignature. The compiler error might help you narrow down which
2312  // parameter is wrong and the types that did not match.
2313  auto r = worklet(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12);
2314 
2315  fetch1.Store(threadIndices, FetchInfo1::GetParameter(invocation), p1);
2316  fetch2.Store(threadIndices, FetchInfo2::GetParameter(invocation), p2);
2317  fetch3.Store(threadIndices, FetchInfo3::GetParameter(invocation), p3);
2318  fetch4.Store(threadIndices, FetchInfo4::GetParameter(invocation), p4);
2319  fetch5.Store(threadIndices, FetchInfo5::GetParameter(invocation), p5);
2320  fetch6.Store(threadIndices, FetchInfo6::GetParameter(invocation), p6);
2321  fetch7.Store(threadIndices, FetchInfo7::GetParameter(invocation), p7);
2322  fetch8.Store(threadIndices, FetchInfo8::GetParameter(invocation), p8);
2323  fetch9.Store(threadIndices, FetchInfo9::GetParameter(invocation), p9);
2324  fetch10.Store(threadIndices, FetchInfo10::GetParameter(invocation), p10);
2325  fetch11.Store(threadIndices, FetchInfo11::GetParameter(invocation), p11);
2326  fetch12.Store(threadIndices, FetchInfo12::GetParameter(invocation), p12);
2327 
2328  returnFetch.Store(threadIndices, FetchInfo0::GetParameter(invocation), r);
2329 }
2330 
2331 template <typename WorkletType,
2332  typename ParameterInterface,
2333  typename ControlInterface,
2334  vtkm::IdComponent InputDomainIndex,
2335  typename OutputToInputMapType,
2336  typename VisitArrayType,
2337  typename ThreadToOutputMapType,
2338  typename DeviceAdapterTag,
2339  typename ThreadIndicesType,
2340  typename P1,
2341  typename P2,
2342  typename P3,
2343  typename P4,
2344  typename P5,
2345  typename P6,
2346  typename P7,
2347  typename P8,
2348  typename P9,
2349  typename P10,
2350  typename P11,
2351  typename P12>
2352 VTKM_EXEC void DoWorkletInvokeFunctor(
2353  const WorkletType& worklet,
2354  const vtkm::internal::Invocation<ParameterInterface,
2355  ControlInterface,
2356  vtkm::internal::FunctionInterface<void(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12)>,
2357  InputDomainIndex,
2358  OutputToInputMapType,
2359  VisitArrayType,
2360  ThreadToOutputMapType,
2361  DeviceAdapterTag>& invocation,
2362  const ThreadIndicesType& threadIndices)
2363 {
2364  using Invocation =
2365  vtkm::internal::Invocation<ParameterInterface,
2366  ControlInterface,
2367  vtkm::internal::FunctionInterface<void(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12)>,
2368  InputDomainIndex,
2369  OutputToInputMapType,
2370  VisitArrayType,
2371  ThreadToOutputMapType,
2372  DeviceAdapterTag>;
2373 
2374  using FetchInfo1 = InvocationToFetch<ThreadIndicesType, Invocation, 1>;
2375  using FetchType1 = typename FetchInfo1::type;
2376  FetchType1 fetch1;
2377  auto p1 =
2378  fetch1.Load(threadIndices, FetchInfo1::GetParameter(invocation));
2379 
2380  using FetchInfo2 = InvocationToFetch<ThreadIndicesType, Invocation, 2>;
2381  using FetchType2 = typename FetchInfo2::type;
2382  FetchType2 fetch2;
2383  auto p2 =
2384  fetch2.Load(threadIndices, FetchInfo2::GetParameter(invocation));
2385 
2386  using FetchInfo3 = InvocationToFetch<ThreadIndicesType, Invocation, 3>;
2387  using FetchType3 = typename FetchInfo3::type;
2388  FetchType3 fetch3;
2389  auto p3 =
2390  fetch3.Load(threadIndices, FetchInfo3::GetParameter(invocation));
2391 
2392  using FetchInfo4 = InvocationToFetch<ThreadIndicesType, Invocation, 4>;
2393  using FetchType4 = typename FetchInfo4::type;
2394  FetchType4 fetch4;
2395  auto p4 =
2396  fetch4.Load(threadIndices, FetchInfo4::GetParameter(invocation));
2397 
2398  using FetchInfo5 = InvocationToFetch<ThreadIndicesType, Invocation, 5>;
2399  using FetchType5 = typename FetchInfo5::type;
2400  FetchType5 fetch5;
2401  auto p5 =
2402  fetch5.Load(threadIndices, FetchInfo5::GetParameter(invocation));
2403 
2404  using FetchInfo6 = InvocationToFetch<ThreadIndicesType, Invocation, 6>;
2405  using FetchType6 = typename FetchInfo6::type;
2406  FetchType6 fetch6;
2407  auto p6 =
2408  fetch6.Load(threadIndices, FetchInfo6::GetParameter(invocation));
2409 
2410  using FetchInfo7 = InvocationToFetch<ThreadIndicesType, Invocation, 7>;
2411  using FetchType7 = typename FetchInfo7::type;
2412  FetchType7 fetch7;
2413  auto p7 =
2414  fetch7.Load(threadIndices, FetchInfo7::GetParameter(invocation));
2415 
2416  using FetchInfo8 = InvocationToFetch<ThreadIndicesType, Invocation, 8>;
2417  using FetchType8 = typename FetchInfo8::type;
2418  FetchType8 fetch8;
2419  auto p8 =
2420  fetch8.Load(threadIndices, FetchInfo8::GetParameter(invocation));
2421 
2422  using FetchInfo9 = InvocationToFetch<ThreadIndicesType, Invocation, 9>;
2423  using FetchType9 = typename FetchInfo9::type;
2424  FetchType9 fetch9;
2425  auto p9 =
2426  fetch9.Load(threadIndices, FetchInfo9::GetParameter(invocation));
2427 
2428  using FetchInfo10 = InvocationToFetch<ThreadIndicesType, Invocation, 10>;
2429  using FetchType10 = typename FetchInfo10::type;
2430  FetchType10 fetch10;
2431  auto p10 =
2432  fetch10.Load(threadIndices, FetchInfo10::GetParameter(invocation));
2433 
2434  using FetchInfo11 = InvocationToFetch<ThreadIndicesType, Invocation, 11>;
2435  using FetchType11 = typename FetchInfo11::type;
2436  FetchType11 fetch11;
2437  auto p11 =
2438  fetch11.Load(threadIndices, FetchInfo11::GetParameter(invocation));
2439 
2440  using FetchInfo12 = InvocationToFetch<ThreadIndicesType, Invocation, 12>;
2441  using FetchType12 = typename FetchInfo12::type;
2442  FetchType12 fetch12;
2443  auto p12 =
2444  fetch12.Load(threadIndices, FetchInfo12::GetParameter(invocation));
2445 
2446  // If you got a compile error on the following line, it probably means that
2447  // the operator() of a worklet does not match the definition expected. One
2448  // common problem is that the operator() method must be declared const. Check
2449  // to make sure the "const" keyword is after parameters. Another common
2450  // problem is that the type of one or more parameters is incompatible with
2451  // the actual type that VTK-m creates in the execution environment. Make sure
2452  // that the types of the worklet operator() parameters match those in the
2453  // ExecutionSignature. The compiler error might help you narrow down which
2454  // parameter is wrong and the types that did not match.
2455  worklet(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12);
2456 
2457  fetch1.Store(threadIndices, FetchInfo1::GetParameter(invocation), p1);
2458  fetch2.Store(threadIndices, FetchInfo2::GetParameter(invocation), p2);
2459  fetch3.Store(threadIndices, FetchInfo3::GetParameter(invocation), p3);
2460  fetch4.Store(threadIndices, FetchInfo4::GetParameter(invocation), p4);
2461  fetch5.Store(threadIndices, FetchInfo5::GetParameter(invocation), p5);
2462  fetch6.Store(threadIndices, FetchInfo6::GetParameter(invocation), p6);
2463  fetch7.Store(threadIndices, FetchInfo7::GetParameter(invocation), p7);
2464  fetch8.Store(threadIndices, FetchInfo8::GetParameter(invocation), p8);
2465  fetch9.Store(threadIndices, FetchInfo9::GetParameter(invocation), p9);
2466  fetch10.Store(threadIndices, FetchInfo10::GetParameter(invocation), p10);
2467  fetch11.Store(threadIndices, FetchInfo11::GetParameter(invocation), p11);
2468  fetch12.Store(threadIndices, FetchInfo12::GetParameter(invocation), p12);
2469 }
2470 
2471 template <typename WorkletType,
2472  typename ParameterInterface,
2473  typename ControlInterface,
2474  vtkm::IdComponent InputDomainIndex,
2475  typename OutputToInputMapType,
2476  typename VisitArrayType,
2477  typename ThreadToOutputMapType,
2478  typename DeviceAdapterTag,
2479  typename ThreadIndicesType,
2480  typename R,
2481  typename P1,
2482  typename P2,
2483  typename P3,
2484  typename P4,
2485  typename P5,
2486  typename P6,
2487  typename P7,
2488  typename P8,
2489  typename P9,
2490  typename P10,
2491  typename P11,
2492  typename P12,
2493  typename P13>
2494 VTKM_EXEC void DoWorkletInvokeFunctor(
2495  const WorkletType& worklet,
2496  const vtkm::internal::Invocation<ParameterInterface,
2497  ControlInterface,
2498  vtkm::internal::FunctionInterface<R(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13)>,
2499  InputDomainIndex,
2500  OutputToInputMapType,
2501  VisitArrayType,
2502  ThreadToOutputMapType,
2503  DeviceAdapterTag>& invocation,
2504  const ThreadIndicesType& threadIndices)
2505 {
2506  using Invocation = vtkm::internal::Invocation<ParameterInterface,
2507  ControlInterface,
2508  vtkm::internal::FunctionInterface<R(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13)>,
2509  InputDomainIndex,
2510  OutputToInputMapType,
2511  VisitArrayType,
2512  ThreadToOutputMapType,
2513  DeviceAdapterTag>;
2514 
2515  using FetchInfo1 = InvocationToFetch<ThreadIndicesType, Invocation, 1>;
2516  using FetchType1 = typename FetchInfo1::type;
2517  FetchType1 fetch1;
2518  auto p1 =
2519  fetch1.Load(threadIndices, FetchInfo1::GetParameter(invocation));
2520 
2521  using FetchInfo2 = InvocationToFetch<ThreadIndicesType, Invocation, 2>;
2522  using FetchType2 = typename FetchInfo2::type;
2523  FetchType2 fetch2;
2524  auto p2 =
2525  fetch2.Load(threadIndices, FetchInfo2::GetParameter(invocation));
2526 
2527  using FetchInfo3 = InvocationToFetch<ThreadIndicesType, Invocation, 3>;
2528  using FetchType3 = typename FetchInfo3::type;
2529  FetchType3 fetch3;
2530  auto p3 =
2531  fetch3.Load(threadIndices, FetchInfo3::GetParameter(invocation));
2532 
2533  using FetchInfo4 = InvocationToFetch<ThreadIndicesType, Invocation, 4>;
2534  using FetchType4 = typename FetchInfo4::type;
2535  FetchType4 fetch4;
2536  auto p4 =
2537  fetch4.Load(threadIndices, FetchInfo4::GetParameter(invocation));
2538 
2539  using FetchInfo5 = InvocationToFetch<ThreadIndicesType, Invocation, 5>;
2540  using FetchType5 = typename FetchInfo5::type;
2541  FetchType5 fetch5;
2542  auto p5 =
2543  fetch5.Load(threadIndices, FetchInfo5::GetParameter(invocation));
2544 
2545  using FetchInfo6 = InvocationToFetch<ThreadIndicesType, Invocation, 6>;
2546  using FetchType6 = typename FetchInfo6::type;
2547  FetchType6 fetch6;
2548  auto p6 =
2549  fetch6.Load(threadIndices, FetchInfo6::GetParameter(invocation));
2550 
2551  using FetchInfo7 = InvocationToFetch<ThreadIndicesType, Invocation, 7>;
2552  using FetchType7 = typename FetchInfo7::type;
2553  FetchType7 fetch7;
2554  auto p7 =
2555  fetch7.Load(threadIndices, FetchInfo7::GetParameter(invocation));
2556 
2557  using FetchInfo8 = InvocationToFetch<ThreadIndicesType, Invocation, 8>;
2558  using FetchType8 = typename FetchInfo8::type;
2559  FetchType8 fetch8;
2560  auto p8 =
2561  fetch8.Load(threadIndices, FetchInfo8::GetParameter(invocation));
2562 
2563  using FetchInfo9 = InvocationToFetch<ThreadIndicesType, Invocation, 9>;
2564  using FetchType9 = typename FetchInfo9::type;
2565  FetchType9 fetch9;
2566  auto p9 =
2567  fetch9.Load(threadIndices, FetchInfo9::GetParameter(invocation));
2568 
2569  using FetchInfo10 = InvocationToFetch<ThreadIndicesType, Invocation, 10>;
2570  using FetchType10 = typename FetchInfo10::type;
2571  FetchType10 fetch10;
2572  auto p10 =
2573  fetch10.Load(threadIndices, FetchInfo10::GetParameter(invocation));
2574 
2575  using FetchInfo11 = InvocationToFetch<ThreadIndicesType, Invocation, 11>;
2576  using FetchType11 = typename FetchInfo11::type;
2577  FetchType11 fetch11;
2578  auto p11 =
2579  fetch11.Load(threadIndices, FetchInfo11::GetParameter(invocation));
2580 
2581  using FetchInfo12 = InvocationToFetch<ThreadIndicesType, Invocation, 12>;
2582  using FetchType12 = typename FetchInfo12::type;
2583  FetchType12 fetch12;
2584  auto p12 =
2585  fetch12.Load(threadIndices, FetchInfo12::GetParameter(invocation));
2586 
2587  using FetchInfo13 = InvocationToFetch<ThreadIndicesType, Invocation, 13>;
2588  using FetchType13 = typename FetchInfo13::type;
2589  FetchType13 fetch13;
2590  auto p13 =
2591  fetch13.Load(threadIndices, FetchInfo13::GetParameter(invocation));
2592 
2593  using FetchInfo0 = InvocationToFetch<ThreadIndicesType, Invocation, 0>;
2594  using ReturnFetchType = typename FetchInfo0::type;
2595  ReturnFetchType returnFetch;
2596  // If you got a compile error on the following line, it probably means that
2597  // the operator() of a worklet does not match the definition expected. One
2598  // common problem is that the operator() method must be declared const. Check
2599  // to make sure the "const" keyword is after parameters. Another common
2600  // problem is that the type of one or more parameters is incompatible with
2601  // the actual type that VTK-m creates in the execution environment. Make sure
2602  // that the types of the worklet operator() parameters match those in the
2603  // ExecutionSignature. The compiler error might help you narrow down which
2604  // parameter is wrong and the types that did not match.
2605  auto r = worklet(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13);
2606 
2607  fetch1.Store(threadIndices, FetchInfo1::GetParameter(invocation), p1);
2608  fetch2.Store(threadIndices, FetchInfo2::GetParameter(invocation), p2);
2609  fetch3.Store(threadIndices, FetchInfo3::GetParameter(invocation), p3);
2610  fetch4.Store(threadIndices, FetchInfo4::GetParameter(invocation), p4);
2611  fetch5.Store(threadIndices, FetchInfo5::GetParameter(invocation), p5);
2612  fetch6.Store(threadIndices, FetchInfo6::GetParameter(invocation), p6);
2613  fetch7.Store(threadIndices, FetchInfo7::GetParameter(invocation), p7);
2614  fetch8.Store(threadIndices, FetchInfo8::GetParameter(invocation), p8);
2615  fetch9.Store(threadIndices, FetchInfo9::GetParameter(invocation), p9);
2616  fetch10.Store(threadIndices, FetchInfo10::GetParameter(invocation), p10);
2617  fetch11.Store(threadIndices, FetchInfo11::GetParameter(invocation), p11);
2618  fetch12.Store(threadIndices, FetchInfo12::GetParameter(invocation), p12);
2619  fetch13.Store(threadIndices, FetchInfo13::GetParameter(invocation), p13);
2620 
2621  returnFetch.Store(threadIndices, FetchInfo0::GetParameter(invocation), r);
2622 }
2623 
2624 template <typename WorkletType,
2625  typename ParameterInterface,
2626  typename ControlInterface,
2627  vtkm::IdComponent InputDomainIndex,
2628  typename OutputToInputMapType,
2629  typename VisitArrayType,
2630  typename ThreadToOutputMapType,
2631  typename DeviceAdapterTag,
2632  typename ThreadIndicesType,
2633  typename P1,
2634  typename P2,
2635  typename P3,
2636  typename P4,
2637  typename P5,
2638  typename P6,
2639  typename P7,
2640  typename P8,
2641  typename P9,
2642  typename P10,
2643  typename P11,
2644  typename P12,
2645  typename P13>
2646 VTKM_EXEC void DoWorkletInvokeFunctor(
2647  const WorkletType& worklet,
2648  const vtkm::internal::Invocation<ParameterInterface,
2649  ControlInterface,
2650  vtkm::internal::FunctionInterface<void(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13)>,
2651  InputDomainIndex,
2652  OutputToInputMapType,
2653  VisitArrayType,
2654  ThreadToOutputMapType,
2655  DeviceAdapterTag>& invocation,
2656  const ThreadIndicesType& threadIndices)
2657 {
2658  using Invocation =
2659  vtkm::internal::Invocation<ParameterInterface,
2660  ControlInterface,
2661  vtkm::internal::FunctionInterface<void(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13)>,
2662  InputDomainIndex,
2663  OutputToInputMapType,
2664  VisitArrayType,
2665  ThreadToOutputMapType,
2666  DeviceAdapterTag>;
2667 
2668  using FetchInfo1 = InvocationToFetch<ThreadIndicesType, Invocation, 1>;
2669  using FetchType1 = typename FetchInfo1::type;
2670  FetchType1 fetch1;
2671  auto p1 =
2672  fetch1.Load(threadIndices, FetchInfo1::GetParameter(invocation));
2673 
2674  using FetchInfo2 = InvocationToFetch<ThreadIndicesType, Invocation, 2>;
2675  using FetchType2 = typename FetchInfo2::type;
2676  FetchType2 fetch2;
2677  auto p2 =
2678  fetch2.Load(threadIndices, FetchInfo2::GetParameter(invocation));
2679 
2680  using FetchInfo3 = InvocationToFetch<ThreadIndicesType, Invocation, 3>;
2681  using FetchType3 = typename FetchInfo3::type;
2682  FetchType3 fetch3;
2683  auto p3 =
2684  fetch3.Load(threadIndices, FetchInfo3::GetParameter(invocation));
2685 
2686  using FetchInfo4 = InvocationToFetch<ThreadIndicesType, Invocation, 4>;
2687  using FetchType4 = typename FetchInfo4::type;
2688  FetchType4 fetch4;
2689  auto p4 =
2690  fetch4.Load(threadIndices, FetchInfo4::GetParameter(invocation));
2691 
2692  using FetchInfo5 = InvocationToFetch<ThreadIndicesType, Invocation, 5>;
2693  using FetchType5 = typename FetchInfo5::type;
2694  FetchType5 fetch5;
2695  auto p5 =
2696  fetch5.Load(threadIndices, FetchInfo5::GetParameter(invocation));
2697 
2698  using FetchInfo6 = InvocationToFetch<ThreadIndicesType, Invocation, 6>;
2699  using FetchType6 = typename FetchInfo6::type;
2700  FetchType6 fetch6;
2701  auto p6 =
2702  fetch6.Load(threadIndices, FetchInfo6::GetParameter(invocation));
2703 
2704  using FetchInfo7 = InvocationToFetch<ThreadIndicesType, Invocation, 7>;
2705  using FetchType7 = typename FetchInfo7::type;
2706  FetchType7 fetch7;
2707  auto p7 =
2708  fetch7.Load(threadIndices, FetchInfo7::GetParameter(invocation));
2709 
2710  using FetchInfo8 = InvocationToFetch<ThreadIndicesType, Invocation, 8>;
2711  using FetchType8 = typename FetchInfo8::type;
2712  FetchType8 fetch8;
2713  auto p8 =
2714  fetch8.Load(threadIndices, FetchInfo8::GetParameter(invocation));
2715 
2716  using FetchInfo9 = InvocationToFetch<ThreadIndicesType, Invocation, 9>;
2717  using FetchType9 = typename FetchInfo9::type;
2718  FetchType9 fetch9;
2719  auto p9 =
2720  fetch9.Load(threadIndices, FetchInfo9::GetParameter(invocation));
2721 
2722  using FetchInfo10 = InvocationToFetch<ThreadIndicesType, Invocation, 10>;
2723  using FetchType10 = typename FetchInfo10::type;
2724  FetchType10 fetch10;
2725  auto p10 =
2726  fetch10.Load(threadIndices, FetchInfo10::GetParameter(invocation));
2727 
2728  using FetchInfo11 = InvocationToFetch<ThreadIndicesType, Invocation, 11>;
2729  using FetchType11 = typename FetchInfo11::type;
2730  FetchType11 fetch11;
2731  auto p11 =
2732  fetch11.Load(threadIndices, FetchInfo11::GetParameter(invocation));
2733 
2734  using FetchInfo12 = InvocationToFetch<ThreadIndicesType, Invocation, 12>;
2735  using FetchType12 = typename FetchInfo12::type;
2736  FetchType12 fetch12;
2737  auto p12 =
2738  fetch12.Load(threadIndices, FetchInfo12::GetParameter(invocation));
2739 
2740  using FetchInfo13 = InvocationToFetch<ThreadIndicesType, Invocation, 13>;
2741  using FetchType13 = typename FetchInfo13::type;
2742  FetchType13 fetch13;
2743  auto p13 =
2744  fetch13.Load(threadIndices, FetchInfo13::GetParameter(invocation));
2745 
2746  // If you got a compile error on the following line, it probably means that
2747  // the operator() of a worklet does not match the definition expected. One
2748  // common problem is that the operator() method must be declared const. Check
2749  // to make sure the "const" keyword is after parameters. Another common
2750  // problem is that the type of one or more parameters is incompatible with
2751  // the actual type that VTK-m creates in the execution environment. Make sure
2752  // that the types of the worklet operator() parameters match those in the
2753  // ExecutionSignature. The compiler error might help you narrow down which
2754  // parameter is wrong and the types that did not match.
2755  worklet(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13);
2756 
2757  fetch1.Store(threadIndices, FetchInfo1::GetParameter(invocation), p1);
2758  fetch2.Store(threadIndices, FetchInfo2::GetParameter(invocation), p2);
2759  fetch3.Store(threadIndices, FetchInfo3::GetParameter(invocation), p3);
2760  fetch4.Store(threadIndices, FetchInfo4::GetParameter(invocation), p4);
2761  fetch5.Store(threadIndices, FetchInfo5::GetParameter(invocation), p5);
2762  fetch6.Store(threadIndices, FetchInfo6::GetParameter(invocation), p6);
2763  fetch7.Store(threadIndices, FetchInfo7::GetParameter(invocation), p7);
2764  fetch8.Store(threadIndices, FetchInfo8::GetParameter(invocation), p8);
2765  fetch9.Store(threadIndices, FetchInfo9::GetParameter(invocation), p9);
2766  fetch10.Store(threadIndices, FetchInfo10::GetParameter(invocation), p10);
2767  fetch11.Store(threadIndices, FetchInfo11::GetParameter(invocation), p11);
2768  fetch12.Store(threadIndices, FetchInfo12::GetParameter(invocation), p12);
2769  fetch13.Store(threadIndices, FetchInfo13::GetParameter(invocation), p13);
2770 }
2771 
2772 template <typename WorkletType,
2773  typename ParameterInterface,
2774  typename ControlInterface,
2775  vtkm::IdComponent InputDomainIndex,
2776  typename OutputToInputMapType,
2777  typename VisitArrayType,
2778  typename ThreadToOutputMapType,
2779  typename DeviceAdapterTag,
2780  typename ThreadIndicesType,
2781  typename R,
2782  typename P1,
2783  typename P2,
2784  typename P3,
2785  typename P4,
2786  typename P5,
2787  typename P6,
2788  typename P7,
2789  typename P8,
2790  typename P9,
2791  typename P10,
2792  typename P11,
2793  typename P12,
2794  typename P13,
2795  typename P14>
2796 VTKM_EXEC void DoWorkletInvokeFunctor(
2797  const WorkletType& worklet,
2798  const vtkm::internal::Invocation<ParameterInterface,
2799  ControlInterface,
2800  vtkm::internal::FunctionInterface<R(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14)>,
2801  InputDomainIndex,
2802  OutputToInputMapType,
2803  VisitArrayType,
2804  ThreadToOutputMapType,
2805  DeviceAdapterTag>& invocation,
2806  const ThreadIndicesType& threadIndices)
2807 {
2808  using Invocation = vtkm::internal::Invocation<ParameterInterface,
2809  ControlInterface,
2810  vtkm::internal::FunctionInterface<R(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14)>,
2811  InputDomainIndex,
2812  OutputToInputMapType,
2813  VisitArrayType,
2814  ThreadToOutputMapType,
2815  DeviceAdapterTag>;
2816 
2817  using FetchInfo1 = InvocationToFetch<ThreadIndicesType, Invocation, 1>;
2818  using FetchType1 = typename FetchInfo1::type;
2819  FetchType1 fetch1;
2820  auto p1 =
2821  fetch1.Load(threadIndices, FetchInfo1::GetParameter(invocation));
2822 
2823  using FetchInfo2 = InvocationToFetch<ThreadIndicesType, Invocation, 2>;
2824  using FetchType2 = typename FetchInfo2::type;
2825  FetchType2 fetch2;
2826  auto p2 =
2827  fetch2.Load(threadIndices, FetchInfo2::GetParameter(invocation));
2828 
2829  using FetchInfo3 = InvocationToFetch<ThreadIndicesType, Invocation, 3>;
2830  using FetchType3 = typename FetchInfo3::type;
2831  FetchType3 fetch3;
2832  auto p3 =
2833  fetch3.Load(threadIndices, FetchInfo3::GetParameter(invocation));
2834 
2835  using FetchInfo4 = InvocationToFetch<ThreadIndicesType, Invocation, 4>;
2836  using FetchType4 = typename FetchInfo4::type;
2837  FetchType4 fetch4;
2838  auto p4 =
2839  fetch4.Load(threadIndices, FetchInfo4::GetParameter(invocation));
2840 
2841  using FetchInfo5 = InvocationToFetch<ThreadIndicesType, Invocation, 5>;
2842  using FetchType5 = typename FetchInfo5::type;
2843  FetchType5 fetch5;
2844  auto p5 =
2845  fetch5.Load(threadIndices, FetchInfo5::GetParameter(invocation));
2846 
2847  using FetchInfo6 = InvocationToFetch<ThreadIndicesType, Invocation, 6>;
2848  using FetchType6 = typename FetchInfo6::type;
2849  FetchType6 fetch6;
2850  auto p6 =
2851  fetch6.Load(threadIndices, FetchInfo6::GetParameter(invocation));
2852 
2853  using FetchInfo7 = InvocationToFetch<ThreadIndicesType, Invocation, 7>;
2854  using FetchType7 = typename FetchInfo7::type;
2855  FetchType7 fetch7;
2856  auto p7 =
2857  fetch7.Load(threadIndices, FetchInfo7::GetParameter(invocation));
2858 
2859  using FetchInfo8 = InvocationToFetch<ThreadIndicesType, Invocation, 8>;
2860  using FetchType8 = typename FetchInfo8::type;
2861  FetchType8 fetch8;
2862  auto p8 =
2863  fetch8.Load(threadIndices, FetchInfo8::GetParameter(invocation));
2864 
2865  using FetchInfo9 = InvocationToFetch<ThreadIndicesType, Invocation, 9>;
2866  using FetchType9 = typename FetchInfo9::type;
2867  FetchType9 fetch9;
2868  auto p9 =
2869  fetch9.Load(threadIndices, FetchInfo9::GetParameter(invocation));
2870 
2871  using FetchInfo10 = InvocationToFetch<ThreadIndicesType, Invocation, 10>;
2872  using FetchType10 = typename FetchInfo10::type;
2873  FetchType10 fetch10;
2874  auto p10 =
2875  fetch10.Load(threadIndices, FetchInfo10::GetParameter(invocation));
2876 
2877  using FetchInfo11 = InvocationToFetch<ThreadIndicesType, Invocation, 11>;
2878  using FetchType11 = typename FetchInfo11::type;
2879  FetchType11 fetch11;
2880  auto p11 =
2881  fetch11.Load(threadIndices, FetchInfo11::GetParameter(invocation));
2882 
2883  using FetchInfo12 = InvocationToFetch<ThreadIndicesType, Invocation, 12>;
2884  using FetchType12 = typename FetchInfo12::type;
2885  FetchType12 fetch12;
2886  auto p12 =
2887  fetch12.Load(threadIndices, FetchInfo12::GetParameter(invocation));
2888 
2889  using FetchInfo13 = InvocationToFetch<ThreadIndicesType, Invocation, 13>;
2890  using FetchType13 = typename FetchInfo13::type;
2891  FetchType13 fetch13;
2892  auto p13 =
2893  fetch13.Load(threadIndices, FetchInfo13::GetParameter(invocation));
2894 
2895  using FetchInfo14 = InvocationToFetch<ThreadIndicesType, Invocation, 14>;
2896  using FetchType14 = typename FetchInfo14::type;
2897  FetchType14 fetch14;
2898  auto p14 =
2899  fetch14.Load(threadIndices, FetchInfo14::GetParameter(invocation));
2900 
2901  using FetchInfo0 = InvocationToFetch<ThreadIndicesType, Invocation, 0>;
2902  using ReturnFetchType = typename FetchInfo0::type;
2903  ReturnFetchType returnFetch;
2904  // If you got a compile error on the following line, it probably means that
2905  // the operator() of a worklet does not match the definition expected. One
2906  // common problem is that the operator() method must be declared const. Check
2907  // to make sure the "const" keyword is after parameters. Another common
2908  // problem is that the type of one or more parameters is incompatible with
2909  // the actual type that VTK-m creates in the execution environment. Make sure
2910  // that the types of the worklet operator() parameters match those in the
2911  // ExecutionSignature. The compiler error might help you narrow down which
2912  // parameter is wrong and the types that did not match.
2913  auto r = worklet(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14);
2914 
2915  fetch1.Store(threadIndices, FetchInfo1::GetParameter(invocation), p1);
2916  fetch2.Store(threadIndices, FetchInfo2::GetParameter(invocation), p2);
2917  fetch3.Store(threadIndices, FetchInfo3::GetParameter(invocation), p3);
2918  fetch4.Store(threadIndices, FetchInfo4::GetParameter(invocation), p4);
2919  fetch5.Store(threadIndices, FetchInfo5::GetParameter(invocation), p5);
2920  fetch6.Store(threadIndices, FetchInfo6::GetParameter(invocation), p6);
2921  fetch7.Store(threadIndices, FetchInfo7::GetParameter(invocation), p7);
2922  fetch8.Store(threadIndices, FetchInfo8::GetParameter(invocation), p8);
2923  fetch9.Store(threadIndices, FetchInfo9::GetParameter(invocation), p9);
2924  fetch10.Store(threadIndices, FetchInfo10::GetParameter(invocation), p10);
2925  fetch11.Store(threadIndices, FetchInfo11::GetParameter(invocation), p11);
2926  fetch12.Store(threadIndices, FetchInfo12::GetParameter(invocation), p12);
2927  fetch13.Store(threadIndices, FetchInfo13::GetParameter(invocation), p13);
2928  fetch14.Store(threadIndices, FetchInfo14::GetParameter(invocation), p14);
2929 
2930  returnFetch.Store(threadIndices, FetchInfo0::GetParameter(invocation), r);
2931 }
2932 
2933 template <typename WorkletType,
2934  typename ParameterInterface,
2935  typename ControlInterface,
2936  vtkm::IdComponent InputDomainIndex,
2937  typename OutputToInputMapType,
2938  typename VisitArrayType,
2939  typename ThreadToOutputMapType,
2940  typename DeviceAdapterTag,
2941  typename ThreadIndicesType,
2942  typename P1,
2943  typename P2,
2944  typename P3,
2945  typename P4,
2946  typename P5,
2947  typename P6,
2948  typename P7,
2949  typename P8,
2950  typename P9,
2951  typename P10,
2952  typename P11,
2953  typename P12,
2954  typename P13,
2955  typename P14>
2956 VTKM_EXEC void DoWorkletInvokeFunctor(
2957  const WorkletType& worklet,
2958  const vtkm::internal::Invocation<ParameterInterface,
2959  ControlInterface,
2960  vtkm::internal::FunctionInterface<void(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14)>,
2961  InputDomainIndex,
2962  OutputToInputMapType,
2963  VisitArrayType,
2964  ThreadToOutputMapType,
2965  DeviceAdapterTag>& invocation,
2966  const ThreadIndicesType& threadIndices)
2967 {
2968  using Invocation =
2969  vtkm::internal::Invocation<ParameterInterface,
2970  ControlInterface,
2971  vtkm::internal::FunctionInterface<void(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14)>,
2972  InputDomainIndex,
2973  OutputToInputMapType,
2974  VisitArrayType,
2975  ThreadToOutputMapType,
2976  DeviceAdapterTag>;
2977 
2978  using FetchInfo1 = InvocationToFetch<ThreadIndicesType, Invocation, 1>;
2979  using FetchType1 = typename FetchInfo1::type;
2980  FetchType1 fetch1;
2981  auto p1 =
2982  fetch1.Load(threadIndices, FetchInfo1::GetParameter(invocation));
2983 
2984  using FetchInfo2 = InvocationToFetch<ThreadIndicesType, Invocation, 2>;
2985  using FetchType2 = typename FetchInfo2::type;
2986  FetchType2 fetch2;
2987  auto p2 =
2988  fetch2.Load(threadIndices, FetchInfo2::GetParameter(invocation));
2989 
2990  using FetchInfo3 = InvocationToFetch<ThreadIndicesType, Invocation, 3>;
2991  using FetchType3 = typename FetchInfo3::type;
2992  FetchType3 fetch3;
2993  auto p3 =
2994  fetch3.Load(threadIndices, FetchInfo3::GetParameter(invocation));
2995 
2996  using FetchInfo4 = InvocationToFetch<ThreadIndicesType, Invocation, 4>;
2997  using FetchType4 = typename FetchInfo4::type;
2998  FetchType4 fetch4;
2999  auto p4 =
3000  fetch4.Load(threadIndices, FetchInfo4::GetParameter(invocation));
3001 
3002  using FetchInfo5 = InvocationToFetch<ThreadIndicesType, Invocation, 5>;
3003  using FetchType5 = typename FetchInfo5::type;
3004  FetchType5 fetch5;
3005  auto p5 =
3006  fetch5.Load(threadIndices, FetchInfo5::GetParameter(invocation));
3007 
3008  using FetchInfo6 = InvocationToFetch<ThreadIndicesType, Invocation, 6>;
3009  using FetchType6 = typename FetchInfo6::type;
3010  FetchType6 fetch6;
3011  auto p6 =
3012  fetch6.Load(threadIndices, FetchInfo6::GetParameter(invocation));
3013 
3014  using FetchInfo7 = InvocationToFetch<ThreadIndicesType, Invocation, 7>;
3015  using FetchType7 = typename FetchInfo7::type;
3016  FetchType7 fetch7;
3017  auto p7 =
3018  fetch7.Load(threadIndices, FetchInfo7::GetParameter(invocation));
3019 
3020  using FetchInfo8 = InvocationToFetch<ThreadIndicesType, Invocation, 8>;
3021  using FetchType8 = typename FetchInfo8::type;
3022  FetchType8 fetch8;
3023  auto p8 =
3024  fetch8.Load(threadIndices, FetchInfo8::GetParameter(invocation));
3025 
3026  using FetchInfo9 = InvocationToFetch<ThreadIndicesType, Invocation, 9>;
3027  using FetchType9 = typename FetchInfo9::type;
3028  FetchType9 fetch9;
3029  auto p9 =
3030  fetch9.Load(threadIndices, FetchInfo9::GetParameter(invocation));
3031 
3032  using FetchInfo10 = InvocationToFetch<ThreadIndicesType, Invocation, 10>;
3033  using FetchType10 = typename FetchInfo10::type;
3034  FetchType10 fetch10;
3035  auto p10 =
3036  fetch10.Load(threadIndices, FetchInfo10::GetParameter(invocation));
3037 
3038  using FetchInfo11 = InvocationToFetch<ThreadIndicesType, Invocation, 11>;
3039  using FetchType11 = typename FetchInfo11::type;
3040  FetchType11 fetch11;
3041  auto p11 =
3042  fetch11.Load(threadIndices, FetchInfo11::GetParameter(invocation));
3043 
3044  using FetchInfo12 = InvocationToFetch<ThreadIndicesType, Invocation, 12>;
3045  using FetchType12 = typename FetchInfo12::type;
3046  FetchType12 fetch12;
3047  auto p12 =
3048  fetch12.Load(threadIndices, FetchInfo12::GetParameter(invocation));
3049 
3050  using FetchInfo13 = InvocationToFetch<ThreadIndicesType, Invocation, 13>;
3051  using FetchType13 = typename FetchInfo13::type;
3052  FetchType13 fetch13;
3053  auto p13 =
3054  fetch13.Load(threadIndices, FetchInfo13::GetParameter(invocation));
3055 
3056  using FetchInfo14 = InvocationToFetch<ThreadIndicesType, Invocation, 14>;
3057  using FetchType14 = typename FetchInfo14::type;
3058  FetchType14 fetch14;
3059  auto p14 =
3060  fetch14.Load(threadIndices, FetchInfo14::GetParameter(invocation));
3061 
3062  // If you got a compile error on the following line, it probably means that
3063  // the operator() of a worklet does not match the definition expected. One
3064  // common problem is that the operator() method must be declared const. Check
3065  // to make sure the "const" keyword is after parameters. Another common
3066  // problem is that the type of one or more parameters is incompatible with
3067  // the actual type that VTK-m creates in the execution environment. Make sure
3068  // that the types of the worklet operator() parameters match those in the
3069  // ExecutionSignature. The compiler error might help you narrow down which
3070  // parameter is wrong and the types that did not match.
3071  worklet(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14);
3072 
3073  fetch1.Store(threadIndices, FetchInfo1::GetParameter(invocation), p1);
3074  fetch2.Store(threadIndices, FetchInfo2::GetParameter(invocation), p2);
3075  fetch3.Store(threadIndices, FetchInfo3::GetParameter(invocation), p3);
3076  fetch4.Store(threadIndices, FetchInfo4::GetParameter(invocation), p4);
3077  fetch5.Store(threadIndices, FetchInfo5::GetParameter(invocation), p5);
3078  fetch6.Store(threadIndices, FetchInfo6::GetParameter(invocation), p6);
3079  fetch7.Store(threadIndices, FetchInfo7::GetParameter(invocation), p7);
3080  fetch8.Store(threadIndices, FetchInfo8::GetParameter(invocation), p8);
3081  fetch9.Store(threadIndices, FetchInfo9::GetParameter(invocation), p9);
3082  fetch10.Store(threadIndices, FetchInfo10::GetParameter(invocation), p10);
3083  fetch11.Store(threadIndices, FetchInfo11::GetParameter(invocation), p11);
3084  fetch12.Store(threadIndices, FetchInfo12::GetParameter(invocation), p12);
3085  fetch13.Store(threadIndices, FetchInfo13::GetParameter(invocation), p13);
3086  fetch14.Store(threadIndices, FetchInfo14::GetParameter(invocation), p14);
3087 }
3088 
3089 template <typename WorkletType,
3090  typename ParameterInterface,
3091  typename ControlInterface,
3092  vtkm::IdComponent InputDomainIndex,
3093  typename OutputToInputMapType,
3094  typename VisitArrayType,
3095  typename ThreadToOutputMapType,
3096  typename DeviceAdapterTag,
3097  typename ThreadIndicesType,
3098  typename R,
3099  typename P1,
3100  typename P2,
3101  typename P3,
3102  typename P4,
3103  typename P5,
3104  typename P6,
3105  typename P7,
3106  typename P8,
3107  typename P9,
3108  typename P10,
3109  typename P11,
3110  typename P12,
3111  typename P13,
3112  typename P14,
3113  typename P15>
3114 VTKM_EXEC void DoWorkletInvokeFunctor(
3115  const WorkletType& worklet,
3116  const vtkm::internal::Invocation<ParameterInterface,
3117  ControlInterface,
3118  vtkm::internal::FunctionInterface<R(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15)>,
3119  InputDomainIndex,
3120  OutputToInputMapType,
3121  VisitArrayType,
3122  ThreadToOutputMapType,
3123  DeviceAdapterTag>& invocation,
3124  const ThreadIndicesType& threadIndices)
3125 {
3126  using Invocation = vtkm::internal::Invocation<ParameterInterface,
3127  ControlInterface,
3128  vtkm::internal::FunctionInterface<R(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15)>,
3129  InputDomainIndex,
3130  OutputToInputMapType,
3131  VisitArrayType,
3132  ThreadToOutputMapType,
3133  DeviceAdapterTag>;
3134 
3135  using FetchInfo1 = InvocationToFetch<ThreadIndicesType, Invocation, 1>;
3136  using FetchType1 = typename FetchInfo1::type;
3137  FetchType1 fetch1;
3138  auto p1 =
3139  fetch1.Load(threadIndices, FetchInfo1::GetParameter(invocation));
3140 
3141  using FetchInfo2 = InvocationToFetch<ThreadIndicesType, Invocation, 2>;
3142  using FetchType2 = typename FetchInfo2::type;
3143  FetchType2 fetch2;
3144  auto p2 =
3145  fetch2.Load(threadIndices, FetchInfo2::GetParameter(invocation));
3146 
3147  using FetchInfo3 = InvocationToFetch<ThreadIndicesType, Invocation, 3>;
3148  using FetchType3 = typename FetchInfo3::type;
3149  FetchType3 fetch3;
3150  auto p3 =
3151  fetch3.Load(threadIndices, FetchInfo3::GetParameter(invocation));
3152 
3153  using FetchInfo4 = InvocationToFetch<ThreadIndicesType, Invocation, 4>;
3154  using FetchType4 = typename FetchInfo4::type;
3155  FetchType4 fetch4;
3156  auto p4 =
3157  fetch4.Load(threadIndices, FetchInfo4::GetParameter(invocation));
3158 
3159  using FetchInfo5 = InvocationToFetch<ThreadIndicesType, Invocation, 5>;
3160  using FetchType5 = typename FetchInfo5::type;
3161  FetchType5 fetch5;
3162  auto p5 =
3163  fetch5.Load(threadIndices, FetchInfo5::GetParameter(invocation));
3164 
3165  using FetchInfo6 = InvocationToFetch<ThreadIndicesType, Invocation, 6>;
3166  using FetchType6 = typename FetchInfo6::type;
3167  FetchType6 fetch6;
3168  auto p6 =
3169  fetch6.Load(threadIndices, FetchInfo6::GetParameter(invocation));
3170 
3171  using FetchInfo7 = InvocationToFetch<ThreadIndicesType, Invocation, 7>;
3172  using FetchType7 = typename FetchInfo7::type;
3173  FetchType7 fetch7;
3174  auto p7 =
3175  fetch7.Load(threadIndices, FetchInfo7::GetParameter(invocation));
3176 
3177  using FetchInfo8 = InvocationToFetch<ThreadIndicesType, Invocation, 8>;
3178  using FetchType8 = typename FetchInfo8::type;
3179  FetchType8 fetch8;
3180  auto p8 =
3181  fetch8.Load(threadIndices, FetchInfo8::GetParameter(invocation));
3182 
3183  using FetchInfo9 = InvocationToFetch<ThreadIndicesType, Invocation, 9>;
3184  using FetchType9 = typename FetchInfo9::type;
3185  FetchType9 fetch9;
3186  auto p9 =
3187  fetch9.Load(threadIndices, FetchInfo9::GetParameter(invocation));
3188 
3189  using FetchInfo10 = InvocationToFetch<ThreadIndicesType, Invocation, 10>;
3190  using FetchType10 = typename FetchInfo10::type;
3191  FetchType10 fetch10;
3192  auto p10 =
3193  fetch10.Load(threadIndices, FetchInfo10::GetParameter(invocation));
3194 
3195  using FetchInfo11 = InvocationToFetch<ThreadIndicesType, Invocation, 11>;
3196  using FetchType11 = typename FetchInfo11::type;
3197  FetchType11 fetch11;
3198  auto p11 =
3199  fetch11.Load(threadIndices, FetchInfo11::GetParameter(invocation));
3200 
3201  using FetchInfo12 = InvocationToFetch<ThreadIndicesType, Invocation, 12>;
3202  using FetchType12 = typename FetchInfo12::type;
3203  FetchType12 fetch12;
3204  auto p12 =
3205  fetch12.Load(threadIndices, FetchInfo12::GetParameter(invocation));
3206 
3207  using FetchInfo13 = InvocationToFetch<ThreadIndicesType, Invocation, 13>;
3208  using FetchType13 = typename FetchInfo13::type;
3209  FetchType13 fetch13;
3210  auto p13 =
3211  fetch13.Load(threadIndices, FetchInfo13::GetParameter(invocation));
3212 
3213  using FetchInfo14 = InvocationToFetch<ThreadIndicesType, Invocation, 14>;
3214  using FetchType14 = typename FetchInfo14::type;
3215  FetchType14 fetch14;
3216  auto p14 =
3217  fetch14.Load(threadIndices, FetchInfo14::GetParameter(invocation));
3218 
3219  using FetchInfo15 = InvocationToFetch<ThreadIndicesType, Invocation, 15>;
3220  using FetchType15 = typename FetchInfo15::type;
3221  FetchType15 fetch15;
3222  auto p15 =
3223  fetch15.Load(threadIndices, FetchInfo15::GetParameter(invocation));
3224 
3225  using FetchInfo0 = InvocationToFetch<ThreadIndicesType, Invocation, 0>;
3226  using ReturnFetchType = typename FetchInfo0::type;
3227  ReturnFetchType returnFetch;
3228  // If you got a compile error on the following line, it probably means that
3229  // the operator() of a worklet does not match the definition expected. One
3230  // common problem is that the operator() method must be declared const. Check
3231  // to make sure the "const" keyword is after parameters. Another common
3232  // problem is that the type of one or more parameters is incompatible with
3233  // the actual type that VTK-m creates in the execution environment. Make sure
3234  // that the types of the worklet operator() parameters match those in the
3235  // ExecutionSignature. The compiler error might help you narrow down which
3236  // parameter is wrong and the types that did not match.
3237  auto r = worklet(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15);
3238 
3239  fetch1.Store(threadIndices, FetchInfo1::GetParameter(invocation), p1);
3240  fetch2.Store(threadIndices, FetchInfo2::GetParameter(invocation), p2);
3241  fetch3.Store(threadIndices, FetchInfo3::GetParameter(invocation), p3);
3242  fetch4.Store(threadIndices, FetchInfo4::GetParameter(invocation), p4);
3243  fetch5.Store(threadIndices, FetchInfo5::GetParameter(invocation), p5);
3244  fetch6.Store(threadIndices, FetchInfo6::GetParameter(invocation), p6);
3245  fetch7.Store(threadIndices, FetchInfo7::GetParameter(invocation), p7);
3246  fetch8.Store(threadIndices, FetchInfo8::GetParameter(invocation), p8);
3247  fetch9.Store(threadIndices, FetchInfo9::GetParameter(invocation), p9);
3248  fetch10.Store(threadIndices, FetchInfo10::GetParameter(invocation), p10);
3249  fetch11.Store(threadIndices, FetchInfo11::GetParameter(invocation), p11);
3250  fetch12.Store(threadIndices, FetchInfo12::GetParameter(invocation), p12);
3251  fetch13.Store(threadIndices, FetchInfo13::GetParameter(invocation), p13);
3252  fetch14.Store(threadIndices, FetchInfo14::GetParameter(invocation), p14);
3253  fetch15.Store(threadIndices, FetchInfo15::GetParameter(invocation), p15);
3254 
3255  returnFetch.Store(threadIndices, FetchInfo0::GetParameter(invocation), r);
3256 }
3257 
3258 template <typename WorkletType,
3259  typename ParameterInterface,
3260  typename ControlInterface,
3261  vtkm::IdComponent InputDomainIndex,
3262  typename OutputToInputMapType,
3263  typename VisitArrayType,
3264  typename ThreadToOutputMapType,
3265  typename DeviceAdapterTag,
3266  typename ThreadIndicesType,
3267  typename P1,
3268  typename P2,
3269  typename P3,
3270  typename P4,
3271  typename P5,
3272  typename P6,
3273  typename P7,
3274  typename P8,
3275  typename P9,
3276  typename P10,
3277  typename P11,
3278  typename P12,
3279  typename P13,
3280  typename P14,
3281  typename P15>
3282 VTKM_EXEC void DoWorkletInvokeFunctor(
3283  const WorkletType& worklet,
3284  const vtkm::internal::Invocation<ParameterInterface,
3285  ControlInterface,
3286  vtkm::internal::FunctionInterface<void(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15)>,
3287  InputDomainIndex,
3288  OutputToInputMapType,
3289  VisitArrayType,
3290  ThreadToOutputMapType,
3291  DeviceAdapterTag>& invocation,
3292  const ThreadIndicesType& threadIndices)
3293 {
3294  using Invocation =
3295  vtkm::internal::Invocation<ParameterInterface,
3296  ControlInterface,
3297  vtkm::internal::FunctionInterface<void(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15)>,
3298  InputDomainIndex,
3299  OutputToInputMapType,
3300  VisitArrayType,
3301  ThreadToOutputMapType,
3302  DeviceAdapterTag>;
3303 
3304  using FetchInfo1 = InvocationToFetch<ThreadIndicesType, Invocation, 1>;
3305  using FetchType1 = typename FetchInfo1::type;
3306  FetchType1 fetch1;
3307  auto p1 =
3308  fetch1.Load(threadIndices, FetchInfo1::GetParameter(invocation));
3309 
3310  using FetchInfo2 = InvocationToFetch<ThreadIndicesType, Invocation, 2>;
3311  using FetchType2 = typename FetchInfo2::type;
3312  FetchType2 fetch2;
3313  auto p2 =
3314  fetch2.Load(threadIndices, FetchInfo2::GetParameter(invocation));
3315 
3316  using FetchInfo3 = InvocationToFetch<ThreadIndicesType, Invocation, 3>;
3317  using FetchType3 = typename FetchInfo3::type;
3318  FetchType3 fetch3;
3319  auto p3 =
3320  fetch3.Load(threadIndices, FetchInfo3::GetParameter(invocation));
3321 
3322  using FetchInfo4 = InvocationToFetch<ThreadIndicesType, Invocation, 4>;
3323  using FetchType4 = typename FetchInfo4::type;
3324  FetchType4 fetch4;
3325  auto p4 =
3326  fetch4.Load(threadIndices, FetchInfo4::GetParameter(invocation));
3327 
3328  using FetchInfo5 = InvocationToFetch<ThreadIndicesType, Invocation, 5>;
3329  using FetchType5 = typename FetchInfo5::type;
3330  FetchType5 fetch5;
3331  auto p5 =
3332  fetch5.Load(threadIndices, FetchInfo5::GetParameter(invocation));
3333 
3334  using FetchInfo6 = InvocationToFetch<ThreadIndicesType, Invocation, 6>;
3335  using FetchType6 = typename FetchInfo6::type;
3336  FetchType6 fetch6;
3337  auto p6 =
3338  fetch6.Load(threadIndices, FetchInfo6::GetParameter(invocation));
3339 
3340  using FetchInfo7 = InvocationToFetch<ThreadIndicesType, Invocation, 7>;
3341  using FetchType7 = typename FetchInfo7::type;
3342  FetchType7 fetch7;
3343  auto p7 =
3344  fetch7.Load(threadIndices, FetchInfo7::GetParameter(invocation));
3345 
3346  using FetchInfo8 = InvocationToFetch<ThreadIndicesType, Invocation, 8>;
3347  using FetchType8 = typename FetchInfo8::type;
3348  FetchType8 fetch8;
3349  auto p8 =
3350  fetch8.Load(threadIndices, FetchInfo8::GetParameter(invocation));
3351 
3352  using FetchInfo9 = InvocationToFetch<ThreadIndicesType, Invocation, 9>;
3353  using FetchType9 = typename FetchInfo9::type;
3354  FetchType9 fetch9;
3355  auto p9 =
3356  fetch9.Load(threadIndices, FetchInfo9::GetParameter(invocation));
3357 
3358  using FetchInfo10 = InvocationToFetch<ThreadIndicesType, Invocation, 10>;
3359  using FetchType10 = typename FetchInfo10::type;
3360  FetchType10 fetch10;
3361  auto p10 =
3362  fetch10.Load(threadIndices, FetchInfo10::GetParameter(invocation));
3363 
3364  using FetchInfo11 = InvocationToFetch<ThreadIndicesType, Invocation, 11>;
3365  using FetchType11 = typename FetchInfo11::type;
3366  FetchType11 fetch11;
3367  auto p11 =
3368  fetch11.Load(threadIndices, FetchInfo11::GetParameter(invocation));
3369 
3370  using FetchInfo12 = InvocationToFetch<ThreadIndicesType, Invocation, 12>;
3371  using FetchType12 = typename FetchInfo12::type;
3372  FetchType12 fetch12;
3373  auto p12 =
3374  fetch12.Load(threadIndices, FetchInfo12::GetParameter(invocation));
3375 
3376  using FetchInfo13 = InvocationToFetch<ThreadIndicesType, Invocation, 13>;
3377  using FetchType13 = typename FetchInfo13::type;
3378  FetchType13 fetch13;
3379  auto p13 =
3380  fetch13.Load(threadIndices, FetchInfo13::GetParameter(invocation));
3381 
3382  using FetchInfo14 = InvocationToFetch<ThreadIndicesType, Invocation, 14>;
3383  using FetchType14 = typename FetchInfo14::type;
3384  FetchType14 fetch14;
3385  auto p14 =
3386  fetch14.Load(threadIndices, FetchInfo14::GetParameter(invocation));
3387 
3388  using FetchInfo15 = InvocationToFetch<ThreadIndicesType, Invocation, 15>;
3389  using FetchType15 = typename FetchInfo15::type;
3390  FetchType15 fetch15;
3391  auto p15 =
3392  fetch15.Load(threadIndices, FetchInfo15::GetParameter(invocation));
3393 
3394  // If you got a compile error on the following line, it probably means that
3395  // the operator() of a worklet does not match the definition expected. One
3396  // common problem is that the operator() method must be declared const. Check
3397  // to make sure the "const" keyword is after parameters. Another common
3398  // problem is that the type of one or more parameters is incompatible with
3399  // the actual type that VTK-m creates in the execution environment. Make sure
3400  // that the types of the worklet operator() parameters match those in the
3401  // ExecutionSignature. The compiler error might help you narrow down which
3402  // parameter is wrong and the types that did not match.
3403  worklet(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15);
3404 
3405  fetch1.Store(threadIndices, FetchInfo1::GetParameter(invocation), p1);
3406  fetch2.Store(threadIndices, FetchInfo2::GetParameter(invocation), p2);
3407  fetch3.Store(threadIndices, FetchInfo3::GetParameter(invocation), p3);
3408  fetch4.Store(threadIndices, FetchInfo4::GetParameter(invocation), p4);
3409  fetch5.Store(threadIndices, FetchInfo5::GetParameter(invocation), p5);
3410  fetch6.Store(threadIndices, FetchInfo6::GetParameter(invocation), p6);
3411  fetch7.Store(threadIndices, FetchInfo7::GetParameter(invocation), p7);
3412  fetch8.Store(threadIndices, FetchInfo8::GetParameter(invocation), p8);
3413  fetch9.Store(threadIndices, FetchInfo9::GetParameter(invocation), p9);
3414  fetch10.Store(threadIndices, FetchInfo10::GetParameter(invocation), p10);
3415  fetch11.Store(threadIndices, FetchInfo11::GetParameter(invocation), p11);
3416  fetch12.Store(threadIndices, FetchInfo12::GetParameter(invocation), p12);
3417  fetch13.Store(threadIndices, FetchInfo13::GetParameter(invocation), p13);
3418  fetch14.Store(threadIndices, FetchInfo14::GetParameter(invocation), p14);
3419  fetch15.Store(threadIndices, FetchInfo15::GetParameter(invocation), p15);
3420 }
3421 
3422 template <typename WorkletType,
3423  typename ParameterInterface,
3424  typename ControlInterface,
3425  vtkm::IdComponent InputDomainIndex,
3426  typename OutputToInputMapType,
3427  typename VisitArrayType,
3428  typename ThreadToOutputMapType,
3429  typename DeviceAdapterTag,
3430  typename ThreadIndicesType,
3431  typename R,
3432  typename P1,
3433  typename P2,
3434  typename P3,
3435  typename P4,
3436  typename P5,
3437  typename P6,
3438  typename P7,
3439  typename P8,
3440  typename P9,
3441  typename P10,
3442  typename P11,
3443  typename P12,
3444  typename P13,
3445  typename P14,
3446  typename P15,
3447  typename P16>
3448 VTKM_EXEC void DoWorkletInvokeFunctor(
3449  const WorkletType& worklet,
3450  const vtkm::internal::Invocation<ParameterInterface,
3451  ControlInterface,
3452  vtkm::internal::FunctionInterface<R(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16)>,
3453  InputDomainIndex,
3454  OutputToInputMapType,
3455  VisitArrayType,
3456  ThreadToOutputMapType,
3457  DeviceAdapterTag>& invocation,
3458  const ThreadIndicesType& threadIndices)
3459 {
3460  using Invocation = vtkm::internal::Invocation<ParameterInterface,
3461  ControlInterface,
3462  vtkm::internal::FunctionInterface<R(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16)>,
3463  InputDomainIndex,
3464  OutputToInputMapType,
3465  VisitArrayType,
3466  ThreadToOutputMapType,
3467  DeviceAdapterTag>;
3468 
3469  using FetchInfo1 = InvocationToFetch<ThreadIndicesType, Invocation, 1>;
3470  using FetchType1 = typename FetchInfo1::type;
3471  FetchType1 fetch1;
3472  auto p1 =
3473  fetch1.Load(threadIndices, FetchInfo1::GetParameter(invocation));
3474 
3475  using FetchInfo2 = InvocationToFetch<ThreadIndicesType, Invocation, 2>;
3476  using FetchType2 = typename FetchInfo2::type;
3477  FetchType2 fetch2;
3478  auto p2 =
3479  fetch2.Load(threadIndices, FetchInfo2::GetParameter(invocation));
3480 
3481  using FetchInfo3 = InvocationToFetch<ThreadIndicesType, Invocation, 3>;
3482  using FetchType3 = typename FetchInfo3::type;
3483  FetchType3 fetch3;
3484  auto p3 =
3485  fetch3.Load(threadIndices, FetchInfo3::GetParameter(invocation));
3486 
3487  using FetchInfo4 = InvocationToFetch<ThreadIndicesType, Invocation, 4>;
3488  using FetchType4 = typename FetchInfo4::type;
3489  FetchType4 fetch4;
3490  auto p4 =
3491  fetch4.Load(threadIndices, FetchInfo4::GetParameter(invocation));
3492 
3493  using FetchInfo5 = InvocationToFetch<ThreadIndicesType, Invocation, 5>;
3494  using FetchType5 = typename FetchInfo5::type;
3495  FetchType5 fetch5;
3496  auto p5 =
3497  fetch5.Load(threadIndices, FetchInfo5::GetParameter(invocation));
3498 
3499  using FetchInfo6 = InvocationToFetch<ThreadIndicesType, Invocation, 6>;
3500  using FetchType6 = typename FetchInfo6::type;
3501  FetchType6 fetch6;
3502  auto p6 =
3503  fetch6.Load(threadIndices, FetchInfo6::GetParameter(invocation));
3504 
3505  using FetchInfo7 = InvocationToFetch<ThreadIndicesType, Invocation, 7>;
3506  using FetchType7 = typename FetchInfo7::type;
3507  FetchType7 fetch7;
3508  auto p7 =
3509  fetch7.Load(threadIndices, FetchInfo7::GetParameter(invocation));
3510 
3511  using FetchInfo8 = InvocationToFetch<ThreadIndicesType, Invocation, 8>;
3512  using FetchType8 = typename FetchInfo8::type;
3513  FetchType8 fetch8;
3514  auto p8 =
3515  fetch8.Load(threadIndices, FetchInfo8::GetParameter(invocation));
3516 
3517  using FetchInfo9 = InvocationToFetch<ThreadIndicesType, Invocation, 9>;
3518  using FetchType9 = typename FetchInfo9::type;
3519  FetchType9 fetch9;
3520  auto p9 =
3521  fetch9.Load(threadIndices, FetchInfo9::GetParameter(invocation));
3522 
3523  using FetchInfo10 = InvocationToFetch<ThreadIndicesType, Invocation, 10>;
3524  using FetchType10 = typename FetchInfo10::type;
3525  FetchType10 fetch10;
3526  auto p10 =
3527  fetch10.Load(threadIndices, FetchInfo10::GetParameter(invocation));
3528 
3529  using FetchInfo11 = InvocationToFetch<ThreadIndicesType, Invocation, 11>;
3530  using FetchType11 = typename FetchInfo11::type;
3531  FetchType11 fetch11;
3532  auto p11 =
3533  fetch11.Load(threadIndices, FetchInfo11::GetParameter(invocation));
3534 
3535  using FetchInfo12 = InvocationToFetch<ThreadIndicesType, Invocation, 12>;
3536  using FetchType12 = typename FetchInfo12::type;
3537  FetchType12 fetch12;
3538  auto p12 =
3539  fetch12.Load(threadIndices, FetchInfo12::GetParameter(invocation));
3540 
3541  using FetchInfo13 = InvocationToFetch<ThreadIndicesType, Invocation, 13>;
3542  using FetchType13 = typename FetchInfo13::type;
3543  FetchType13 fetch13;
3544  auto p13 =
3545  fetch13.Load(threadIndices, FetchInfo13::GetParameter(invocation));
3546 
3547  using FetchInfo14 = InvocationToFetch<ThreadIndicesType, Invocation, 14>;
3548  using FetchType14 = typename FetchInfo14::type;
3549  FetchType14 fetch14;
3550  auto p14 =
3551  fetch14.Load(threadIndices, FetchInfo14::GetParameter(invocation));
3552 
3553  using FetchInfo15 = InvocationToFetch<ThreadIndicesType, Invocation, 15>;
3554  using FetchType15 = typename FetchInfo15::type;
3555  FetchType15 fetch15;
3556  auto p15 =
3557  fetch15.Load(threadIndices, FetchInfo15::GetParameter(invocation));
3558 
3559  using FetchInfo16 = InvocationToFetch<ThreadIndicesType, Invocation, 16>;
3560  using FetchType16 = typename FetchInfo16::type;
3561  FetchType16 fetch16;
3562  auto p16 =
3563  fetch16.Load(threadIndices, FetchInfo16::GetParameter(invocation));
3564 
3565  using FetchInfo0 = InvocationToFetch<ThreadIndicesType, Invocation, 0>;
3566  using ReturnFetchType = typename FetchInfo0::type;
3567  ReturnFetchType returnFetch;
3568  // If you got a compile error on the following line, it probably means that
3569  // the operator() of a worklet does not match the definition expected. One
3570  // common problem is that the operator() method must be declared const. Check
3571  // to make sure the "const" keyword is after parameters. Another common
3572  // problem is that the type of one or more parameters is incompatible with
3573  // the actual type that VTK-m creates in the execution environment. Make sure
3574  // that the types of the worklet operator() parameters match those in the
3575  // ExecutionSignature. The compiler error might help you narrow down which
3576  // parameter is wrong and the types that did not match.
3577  auto r = worklet(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16);
3578 
3579  fetch1.Store(threadIndices, FetchInfo1::GetParameter(invocation), p1);
3580  fetch2.Store(threadIndices, FetchInfo2::GetParameter(invocation), p2);
3581  fetch3.Store(threadIndices, FetchInfo3::GetParameter(invocation), p3);
3582  fetch4.Store(threadIndices, FetchInfo4::GetParameter(invocation), p4);
3583  fetch5.Store(threadIndices, FetchInfo5::GetParameter(invocation), p5);
3584  fetch6.Store(threadIndices, FetchInfo6::GetParameter(invocation), p6);
3585  fetch7.Store(threadIndices, FetchInfo7::GetParameter(invocation), p7);
3586  fetch8.Store(threadIndices, FetchInfo8::GetParameter(invocation), p8);
3587  fetch9.Store(threadIndices, FetchInfo9::GetParameter(invocation), p9);
3588  fetch10.Store(threadIndices, FetchInfo10::GetParameter(invocation), p10);
3589  fetch11.Store(threadIndices, FetchInfo11::GetParameter(invocation), p11);
3590  fetch12.Store(threadIndices, FetchInfo12::GetParameter(invocation), p12);
3591  fetch13.Store(threadIndices, FetchInfo13::GetParameter(invocation), p13);
3592  fetch14.Store(threadIndices, FetchInfo14::GetParameter(invocation), p14);
3593  fetch15.Store(threadIndices, FetchInfo15::GetParameter(invocation), p15);
3594  fetch16.Store(threadIndices, FetchInfo16::GetParameter(invocation), p16);
3595 
3596  returnFetch.Store(threadIndices, FetchInfo0::GetParameter(invocation), r);
3597 }
3598 
3599 template <typename WorkletType,
3600  typename ParameterInterface,
3601  typename ControlInterface,
3602  vtkm::IdComponent InputDomainIndex,
3603  typename OutputToInputMapType,
3604  typename VisitArrayType,
3605  typename ThreadToOutputMapType,
3606  typename DeviceAdapterTag,
3607  typename ThreadIndicesType,
3608  typename P1,
3609  typename P2,
3610  typename P3,
3611  typename P4,
3612  typename P5,
3613  typename P6,
3614  typename P7,
3615  typename P8,
3616  typename P9,
3617  typename P10,
3618  typename P11,
3619  typename P12,
3620  typename P13,
3621  typename P14,
3622  typename P15,
3623  typename P16>
3624 VTKM_EXEC void DoWorkletInvokeFunctor(
3625  const WorkletType& worklet,
3626  const vtkm::internal::Invocation<ParameterInterface,
3627  ControlInterface,
3628  vtkm::internal::FunctionInterface<void(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16)>,
3629  InputDomainIndex,
3630  OutputToInputMapType,
3631  VisitArrayType,
3632  ThreadToOutputMapType,
3633  DeviceAdapterTag>& invocation,
3634  const ThreadIndicesType& threadIndices)
3635 {
3636  using Invocation =
3637  vtkm::internal::Invocation<ParameterInterface,
3638  ControlInterface,
3639  vtkm::internal::FunctionInterface<void(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16)>,
3640  InputDomainIndex,
3641  OutputToInputMapType,
3642  VisitArrayType,
3643  ThreadToOutputMapType,
3644  DeviceAdapterTag>;
3645 
3646  using FetchInfo1 = InvocationToFetch<ThreadIndicesType, Invocation, 1>;
3647  using FetchType1 = typename FetchInfo1::type;
3648  FetchType1 fetch1;
3649  auto p1 =
3650  fetch1.Load(threadIndices, FetchInfo1::GetParameter(invocation));
3651 
3652  using FetchInfo2 = InvocationToFetch<ThreadIndicesType, Invocation, 2>;
3653  using FetchType2 = typename FetchInfo2::type;
3654  FetchType2 fetch2;
3655  auto p2 =
3656  fetch2.Load(threadIndices, FetchInfo2::GetParameter(invocation));
3657 
3658  using FetchInfo3 = InvocationToFetch<ThreadIndicesType, Invocation, 3>;
3659  using FetchType3 = typename FetchInfo3::type;
3660  FetchType3 fetch3;
3661  auto p3 =
3662  fetch3.Load(threadIndices, FetchInfo3::GetParameter(invocation));
3663 
3664  using FetchInfo4 = InvocationToFetch<ThreadIndicesType, Invocation, 4>;
3665  using FetchType4 = typename FetchInfo4::type;
3666  FetchType4 fetch4;
3667  auto p4 =
3668  fetch4.Load(threadIndices, FetchInfo4::GetParameter(invocation));
3669 
3670  using FetchInfo5 = InvocationToFetch<ThreadIndicesType, Invocation, 5>;
3671  using FetchType5 = typename FetchInfo5::type;
3672  FetchType5 fetch5;
3673  auto p5 =
3674  fetch5.Load(threadIndices, FetchInfo5::GetParameter(invocation));
3675 
3676  using FetchInfo6 = InvocationToFetch<ThreadIndicesType, Invocation, 6>;
3677  using FetchType6 = typename FetchInfo6::type;
3678  FetchType6 fetch6;
3679  auto p6 =
3680  fetch6.Load(threadIndices, FetchInfo6::GetParameter(invocation));
3681 
3682  using FetchInfo7 = InvocationToFetch<ThreadIndicesType, Invocation, 7>;
3683  using FetchType7 = typename FetchInfo7::type;
3684  FetchType7 fetch7;
3685  auto p7 =
3686  fetch7.Load(threadIndices, FetchInfo7::GetParameter(invocation));
3687 
3688  using FetchInfo8 = InvocationToFetch<ThreadIndicesType, Invocation, 8>;
3689  using FetchType8 = typename FetchInfo8::type;
3690  FetchType8 fetch8;
3691  auto p8 =
3692  fetch8.Load(threadIndices, FetchInfo8::GetParameter(invocation));
3693 
3694  using FetchInfo9 = InvocationToFetch<ThreadIndicesType, Invocation, 9>;
3695  using FetchType9 = typename FetchInfo9::type;
3696  FetchType9 fetch9;
3697  auto p9 =
3698  fetch9.Load(threadIndices, FetchInfo9::GetParameter(invocation));
3699 
3700  using FetchInfo10 = InvocationToFetch<ThreadIndicesType, Invocation, 10>;
3701  using FetchType10 = typename FetchInfo10::type;
3702  FetchType10 fetch10;
3703  auto p10 =
3704  fetch10.Load(threadIndices, FetchInfo10::GetParameter(invocation));
3705 
3706  using FetchInfo11 = InvocationToFetch<ThreadIndicesType, Invocation, 11>;
3707  using FetchType11 = typename FetchInfo11::type;
3708  FetchType11 fetch11;
3709  auto p11 =
3710  fetch11.Load(threadIndices, FetchInfo11::GetParameter(invocation));
3711 
3712  using FetchInfo12 = InvocationToFetch<ThreadIndicesType, Invocation, 12>;
3713  using FetchType12 = typename FetchInfo12::type;
3714  FetchType12 fetch12;
3715  auto p12 =
3716  fetch12.Load(threadIndices, FetchInfo12::GetParameter(invocation));
3717 
3718  using FetchInfo13 = InvocationToFetch<ThreadIndicesType, Invocation, 13>;
3719  using FetchType13 = typename FetchInfo13::type;
3720  FetchType13 fetch13;
3721  auto p13 =
3722  fetch13.Load(threadIndices, FetchInfo13::GetParameter(invocation));
3723 
3724  using FetchInfo14 = InvocationToFetch<ThreadIndicesType, Invocation, 14>;
3725  using FetchType14 = typename FetchInfo14::type;
3726  FetchType14 fetch14;
3727  auto p14 =
3728  fetch14.Load(threadIndices, FetchInfo14::GetParameter(invocation));
3729 
3730  using FetchInfo15 = InvocationToFetch<ThreadIndicesType, Invocation, 15>;
3731  using FetchType15 = typename FetchInfo15::type;
3732  FetchType15 fetch15;
3733  auto p15 =
3734  fetch15.Load(threadIndices, FetchInfo15::GetParameter(invocation));
3735 
3736  using FetchInfo16 = InvocationToFetch<ThreadIndicesType, Invocation, 16>;
3737  using FetchType16 = typename FetchInfo16::type;
3738  FetchType16 fetch16;
3739  auto p16 =
3740  fetch16.Load(threadIndices, FetchInfo16::GetParameter(invocation));
3741 
3742  // If you got a compile error on the following line, it probably means that
3743  // the operator() of a worklet does not match the definition expected. One
3744  // common problem is that the operator() method must be declared const. Check
3745  // to make sure the "const" keyword is after parameters. Another common
3746  // problem is that the type of one or more parameters is incompatible with
3747  // the actual type that VTK-m creates in the execution environment. Make sure
3748  // that the types of the worklet operator() parameters match those in the
3749  // ExecutionSignature. The compiler error might help you narrow down which
3750  // parameter is wrong and the types that did not match.
3751  worklet(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16);
3752 
3753  fetch1.Store(threadIndices, FetchInfo1::GetParameter(invocation), p1);
3754  fetch2.Store(threadIndices, FetchInfo2::GetParameter(invocation), p2);
3755  fetch3.Store(threadIndices, FetchInfo3::GetParameter(invocation), p3);
3756  fetch4.Store(threadIndices, FetchInfo4::GetParameter(invocation), p4);
3757  fetch5.Store(threadIndices, FetchInfo5::GetParameter(invocation), p5);
3758  fetch6.Store(threadIndices, FetchInfo6::GetParameter(invocation), p6);
3759  fetch7.Store(threadIndices, FetchInfo7::GetParameter(invocation), p7);
3760  fetch8.Store(threadIndices, FetchInfo8::GetParameter(invocation), p8);
3761  fetch9.Store(threadIndices, FetchInfo9::GetParameter(invocation), p9);
3762  fetch10.Store(threadIndices, FetchInfo10::GetParameter(invocation), p10);
3763  fetch11.Store(threadIndices, FetchInfo11::GetParameter(invocation), p11);
3764  fetch12.Store(threadIndices, FetchInfo12::GetParameter(invocation), p12);
3765  fetch13.Store(threadIndices, FetchInfo13::GetParameter(invocation), p13);
3766  fetch14.Store(threadIndices, FetchInfo14::GetParameter(invocation), p14);
3767  fetch15.Store(threadIndices, FetchInfo15::GetParameter(invocation), p15);
3768  fetch16.Store(threadIndices, FetchInfo16::GetParameter(invocation), p16);
3769 }
3770 
3771 template <typename WorkletType,
3772  typename ParameterInterface,
3773  typename ControlInterface,
3774  vtkm::IdComponent InputDomainIndex,
3775  typename OutputToInputMapType,
3776  typename VisitArrayType,
3777  typename ThreadToOutputMapType,
3778  typename DeviceAdapterTag,
3779  typename ThreadIndicesType,
3780  typename R,
3781  typename P1,
3782  typename P2,
3783  typename P3,
3784  typename P4,
3785  typename P5,
3786  typename P6,
3787  typename P7,
3788  typename P8,
3789  typename P9,
3790  typename P10,
3791  typename P11,
3792  typename P12,
3793  typename P13,
3794  typename P14,
3795  typename P15,
3796  typename P16,
3797  typename P17>
3798 VTKM_EXEC void DoWorkletInvokeFunctor(
3799  const WorkletType& worklet,
3800  const vtkm::internal::Invocation<ParameterInterface,
3801  ControlInterface,
3802  vtkm::internal::FunctionInterface<R(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17)>,
3803  InputDomainIndex,
3804  OutputToInputMapType,
3805  VisitArrayType,
3806  ThreadToOutputMapType,
3807  DeviceAdapterTag>& invocation,
3808  const ThreadIndicesType& threadIndices)
3809 {
3810  using Invocation = vtkm::internal::Invocation<ParameterInterface,
3811  ControlInterface,
3812  vtkm::internal::FunctionInterface<R(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17)>,
3813  InputDomainIndex,
3814  OutputToInputMapType,
3815  VisitArrayType,
3816  ThreadToOutputMapType,
3817  DeviceAdapterTag>;
3818 
3819  using FetchInfo1 = InvocationToFetch<ThreadIndicesType, Invocation, 1>;
3820  using FetchType1 = typename FetchInfo1::type;
3821  FetchType1 fetch1;
3822  auto p1 =
3823  fetch1.Load(threadIndices, FetchInfo1::GetParameter(invocation));
3824 
3825  using FetchInfo2 = InvocationToFetch<ThreadIndicesType, Invocation, 2>;
3826  using FetchType2 = typename FetchInfo2::type;
3827  FetchType2 fetch2;
3828  auto p2 =
3829  fetch2.Load(threadIndices, FetchInfo2::GetParameter(invocation));
3830 
3831  using FetchInfo3 = InvocationToFetch<ThreadIndicesType, Invocation, 3>;
3832  using FetchType3 = typename FetchInfo3::type;
3833  FetchType3 fetch3;
3834  auto p3 =
3835  fetch3.Load(threadIndices, FetchInfo3::GetParameter(invocation));
3836 
3837  using FetchInfo4 = InvocationToFetch<ThreadIndicesType, Invocation, 4>;
3838  using FetchType4 = typename FetchInfo4::type;
3839  FetchType4 fetch4;
3840  auto p4 =
3841  fetch4.Load(threadIndices, FetchInfo4::GetParameter(invocation));
3842 
3843  using FetchInfo5 = InvocationToFetch<ThreadIndicesType, Invocation, 5>;
3844  using FetchType5 = typename FetchInfo5::type;
3845  FetchType5 fetch5;
3846  auto p5 =
3847  fetch5.Load(threadIndices, FetchInfo5::GetParameter(invocation));
3848 
3849  using FetchInfo6 = InvocationToFetch<ThreadIndicesType, Invocation, 6>;
3850  using FetchType6 = typename FetchInfo6::type;
3851  FetchType6 fetch6;
3852  auto p6 =
3853  fetch6.Load(threadIndices, FetchInfo6::GetParameter(invocation));
3854 
3855  using FetchInfo7 = InvocationToFetch<ThreadIndicesType, Invocation, 7>;
3856  using FetchType7 = typename FetchInfo7::type;
3857  FetchType7 fetch7;
3858  auto p7 =
3859  fetch7.Load(threadIndices, FetchInfo7::GetParameter(invocation));
3860 
3861  using FetchInfo8 = InvocationToFetch<ThreadIndicesType, Invocation, 8>;
3862  using FetchType8 = typename FetchInfo8::type;
3863  FetchType8 fetch8;
3864  auto p8 =
3865  fetch8.Load(threadIndices, FetchInfo8::GetParameter(invocation));
3866 
3867  using FetchInfo9 = InvocationToFetch<ThreadIndicesType, Invocation, 9>;
3868  using FetchType9 = typename FetchInfo9::type;
3869  FetchType9 fetch9;
3870  auto p9 =
3871  fetch9.Load(threadIndices, FetchInfo9::GetParameter(invocation));
3872 
3873  using FetchInfo10 = InvocationToFetch<ThreadIndicesType, Invocation, 10>;
3874  using FetchType10 = typename FetchInfo10::type;
3875  FetchType10 fetch10;
3876  auto p10 =
3877  fetch10.Load(threadIndices, FetchInfo10::GetParameter(invocation));
3878 
3879  using FetchInfo11 = InvocationToFetch<ThreadIndicesType, Invocation, 11>;
3880  using FetchType11 = typename FetchInfo11::type;
3881  FetchType11 fetch11;
3882  auto p11 =
3883  fetch11.Load(threadIndices, FetchInfo11::GetParameter(invocation));
3884 
3885  using FetchInfo12 = InvocationToFetch<ThreadIndicesType, Invocation, 12>;
3886  using FetchType12 = typename FetchInfo12::type;
3887  FetchType12 fetch12;
3888  auto p12 =
3889  fetch12.Load(threadIndices, FetchInfo12::GetParameter(invocation));
3890 
3891  using FetchInfo13 = InvocationToFetch<ThreadIndicesType, Invocation, 13>;
3892  using FetchType13 = typename FetchInfo13::type;
3893  FetchType13 fetch13;
3894  auto p13 =
3895  fetch13.Load(threadIndices, FetchInfo13::GetParameter(invocation));
3896 
3897  using FetchInfo14 = InvocationToFetch<ThreadIndicesType, Invocation, 14>;
3898  using FetchType14 = typename FetchInfo14::type;
3899  FetchType14 fetch14;
3900  auto p14 =
3901  fetch14.Load(threadIndices, FetchInfo14::GetParameter(invocation));
3902 
3903  using FetchInfo15 = InvocationToFetch<ThreadIndicesType, Invocation, 15>;
3904  using FetchType15 = typename FetchInfo15::type;
3905  FetchType15 fetch15;
3906  auto p15 =
3907  fetch15.Load(threadIndices, FetchInfo15::GetParameter(invocation));
3908 
3909  using FetchInfo16 = InvocationToFetch<ThreadIndicesType, Invocation, 16>;
3910  using FetchType16 = typename FetchInfo16::type;
3911  FetchType16 fetch16;
3912  auto p16 =
3913  fetch16.Load(threadIndices, FetchInfo16::GetParameter(invocation));
3914 
3915  using FetchInfo17 = InvocationToFetch<ThreadIndicesType, Invocation, 17>;
3916  using FetchType17 = typename FetchInfo17::type;
3917  FetchType17 fetch17;
3918  auto p17 =
3919  fetch17.Load(threadIndices, FetchInfo17::GetParameter(invocation));
3920 
3921  using FetchInfo0 = InvocationToFetch<ThreadIndicesType, Invocation, 0>;
3922  using ReturnFetchType = typename FetchInfo0::type;
3923  ReturnFetchType returnFetch;
3924  // If you got a compile error on the following line, it probably means that
3925  // the operator() of a worklet does not match the definition expected. One
3926  // common problem is that the operator() method must be declared const. Check
3927  // to make sure the "const" keyword is after parameters. Another common
3928  // problem is that the type of one or more parameters is incompatible with
3929  // the actual type that VTK-m creates in the execution environment. Make sure
3930  // that the types of the worklet operator() parameters match those in the
3931  // ExecutionSignature. The compiler error might help you narrow down which
3932  // parameter is wrong and the types that did not match.
3933  auto r = worklet(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17);
3934 
3935  fetch1.Store(threadIndices, FetchInfo1::GetParameter(invocation), p1);
3936  fetch2.Store(threadIndices, FetchInfo2::GetParameter(invocation), p2);
3937  fetch3.Store(threadIndices, FetchInfo3::GetParameter(invocation), p3);
3938  fetch4.Store(threadIndices, FetchInfo4::GetParameter(invocation), p4);
3939  fetch5.Store(threadIndices, FetchInfo5::GetParameter(invocation), p5);
3940  fetch6.Store(threadIndices, FetchInfo6::GetParameter(invocation), p6);
3941  fetch7.Store(threadIndices, FetchInfo7::GetParameter(invocation), p7);
3942  fetch8.Store(threadIndices, FetchInfo8::GetParameter(invocation), p8);
3943  fetch9.Store(threadIndices, FetchInfo9::GetParameter(invocation), p9);
3944  fetch10.Store(threadIndices, FetchInfo10::GetParameter(invocation), p10);
3945  fetch11.Store(threadIndices, FetchInfo11::GetParameter(invocation), p11);
3946  fetch12.Store(threadIndices, FetchInfo12::GetParameter(invocation), p12);
3947  fetch13.Store(threadIndices, FetchInfo13::GetParameter(invocation), p13);
3948  fetch14.Store(threadIndices, FetchInfo14::GetParameter(invocation), p14);
3949  fetch15.Store(threadIndices, FetchInfo15::GetParameter(invocation), p15);
3950  fetch16.Store(threadIndices, FetchInfo16::GetParameter(invocation), p16);
3951  fetch17.Store(threadIndices, FetchInfo17::GetParameter(invocation), p17);
3952 
3953  returnFetch.Store(threadIndices, FetchInfo0::GetParameter(invocation), r);
3954 }
3955 
3956 template <typename WorkletType,
3957  typename ParameterInterface,
3958  typename ControlInterface,
3959  vtkm::IdComponent InputDomainIndex,
3960  typename OutputToInputMapType,
3961  typename VisitArrayType,
3962  typename ThreadToOutputMapType,
3963  typename DeviceAdapterTag,
3964  typename ThreadIndicesType,
3965  typename P1,
3966  typename P2,
3967  typename P3,
3968  typename P4,
3969  typename P5,
3970  typename P6,
3971  typename P7,
3972  typename P8,
3973  typename P9,
3974  typename P10,
3975  typename P11,
3976  typename P12,
3977  typename P13,
3978  typename P14,
3979  typename P15,
3980  typename P16,
3981  typename P17>
3982 VTKM_EXEC void DoWorkletInvokeFunctor(
3983  const WorkletType& worklet,
3984  const vtkm::internal::Invocation<ParameterInterface,
3985  ControlInterface,
3986  vtkm::internal::FunctionInterface<void(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17)>,
3987  InputDomainIndex,
3988  OutputToInputMapType,
3989  VisitArrayType,
3990  ThreadToOutputMapType,
3991  DeviceAdapterTag>& invocation,
3992  const ThreadIndicesType& threadIndices)
3993 {
3994  using Invocation =
3995  vtkm::internal::Invocation<ParameterInterface,
3996  ControlInterface,
3997  vtkm::internal::FunctionInterface<void(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17)>,
3998  InputDomainIndex,
3999  OutputToInputMapType,
4000  VisitArrayType,
4001  ThreadToOutputMapType,
4002  DeviceAdapterTag>;
4003 
4004  using FetchInfo1 = InvocationToFetch<ThreadIndicesType, Invocation, 1>;
4005  using FetchType1 = typename FetchInfo1::type;
4006  FetchType1 fetch1;
4007  auto p1 =
4008  fetch1.Load(threadIndices, FetchInfo1::GetParameter(invocation));
4009 
4010  using FetchInfo2 = InvocationToFetch<ThreadIndicesType, Invocation, 2>;
4011  using FetchType2 = typename FetchInfo2::type;
4012  FetchType2 fetch2;
4013  auto p2 =
4014  fetch2.Load(threadIndices, FetchInfo2::GetParameter(invocation));
4015 
4016  using FetchInfo3 = InvocationToFetch<ThreadIndicesType, Invocation, 3>;
4017  using FetchType3 = typename FetchInfo3::type;
4018  FetchType3 fetch3;
4019  auto p3 =
4020  fetch3.Load(threadIndices, FetchInfo3::GetParameter(invocation));
4021 
4022  using FetchInfo4 = InvocationToFetch<ThreadIndicesType, Invocation, 4>;
4023  using FetchType4 = typename FetchInfo4::type;
4024  FetchType4 fetch4;
4025  auto p4 =
4026  fetch4.Load(threadIndices, FetchInfo4::GetParameter(invocation));
4027 
4028  using FetchInfo5 = InvocationToFetch<ThreadIndicesType, Invocation, 5>;
4029  using FetchType5 = typename FetchInfo5::type;
4030  FetchType5 fetch5;
4031  auto p5 =
4032  fetch5.Load(threadIndices, FetchInfo5::GetParameter(invocation));
4033 
4034  using FetchInfo6 = InvocationToFetch<ThreadIndicesType, Invocation, 6>;
4035  using FetchType6 = typename FetchInfo6::type;
4036  FetchType6 fetch6;
4037  auto p6 =
4038  fetch6.Load(threadIndices, FetchInfo6::GetParameter(invocation));
4039 
4040  using FetchInfo7 = InvocationToFetch<ThreadIndicesType, Invocation, 7>;
4041  using FetchType7 = typename FetchInfo7::type;
4042  FetchType7 fetch7;
4043  auto p7 =
4044  fetch7.Load(threadIndices, FetchInfo7::GetParameter(invocation));
4045 
4046  using FetchInfo8 = InvocationToFetch<ThreadIndicesType, Invocation, 8>;
4047  using FetchType8 = typename FetchInfo8::type;
4048  FetchType8 fetch8;
4049  auto p8 =
4050  fetch8.Load(threadIndices, FetchInfo8::GetParameter(invocation));
4051 
4052  using FetchInfo9 = InvocationToFetch<ThreadIndicesType, Invocation, 9>;
4053  using FetchType9 = typename FetchInfo9::type;
4054  FetchType9 fetch9;
4055  auto p9 =
4056  fetch9.Load(threadIndices, FetchInfo9::GetParameter(invocation));
4057 
4058  using FetchInfo10 = InvocationToFetch<ThreadIndicesType, Invocation, 10>;
4059  using FetchType10 = typename FetchInfo10::type;
4060  FetchType10 fetch10;
4061  auto p10 =
4062  fetch10.Load(threadIndices, FetchInfo10::GetParameter(invocation));
4063 
4064  using FetchInfo11 = InvocationToFetch<ThreadIndicesType, Invocation, 11>;
4065  using FetchType11 = typename FetchInfo11::type;
4066  FetchType11 fetch11;
4067  auto p11 =
4068  fetch11.Load(threadIndices, FetchInfo11::GetParameter(invocation));
4069 
4070  using FetchInfo12 = InvocationToFetch<ThreadIndicesType, Invocation, 12>;
4071  using FetchType12 = typename FetchInfo12::type;
4072  FetchType12 fetch12;
4073  auto p12 =
4074  fetch12.Load(threadIndices, FetchInfo12::GetParameter(invocation));
4075 
4076  using FetchInfo13 = InvocationToFetch<ThreadIndicesType, Invocation, 13>;
4077  using FetchType13 = typename FetchInfo13::type;
4078  FetchType13 fetch13;
4079  auto p13 =
4080  fetch13.Load(threadIndices, FetchInfo13::GetParameter(invocation));
4081 
4082  using FetchInfo14 = InvocationToFetch<ThreadIndicesType, Invocation, 14>;
4083  using FetchType14 = typename FetchInfo14::type;
4084  FetchType14 fetch14;
4085  auto p14 =
4086  fetch14.Load(threadIndices, FetchInfo14::GetParameter(invocation));
4087 
4088  using FetchInfo15 = InvocationToFetch<ThreadIndicesType, Invocation, 15>;
4089  using FetchType15 = typename FetchInfo15::type;
4090  FetchType15 fetch15;
4091  auto p15 =
4092  fetch15.Load(threadIndices, FetchInfo15::GetParameter(invocation));
4093 
4094  using FetchInfo16 = InvocationToFetch<ThreadIndicesType, Invocation, 16>;
4095  using FetchType16 = typename FetchInfo16::type;
4096  FetchType16 fetch16;
4097  auto p16 =
4098  fetch16.Load(threadIndices, FetchInfo16::GetParameter(invocation));
4099 
4100  using FetchInfo17 = InvocationToFetch<ThreadIndicesType, Invocation, 17>;
4101  using FetchType17 = typename FetchInfo17::type;
4102  FetchType17 fetch17;
4103  auto p17 =
4104  fetch17.Load(threadIndices, FetchInfo17::GetParameter(invocation));
4105 
4106  // If you got a compile error on the following line, it probably means that
4107  // the operator() of a worklet does not match the definition expected. One
4108  // common problem is that the operator() method must be declared const. Check
4109  // to make sure the "const" keyword is after parameters. Another common
4110  // problem is that the type of one or more parameters is incompatible with
4111  // the actual type that VTK-m creates in the execution environment. Make sure
4112  // that the types of the worklet operator() parameters match those in the
4113  // ExecutionSignature. The compiler error might help you narrow down which
4114  // parameter is wrong and the types that did not match.
4115  worklet(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17);
4116 
4117  fetch1.Store(threadIndices, FetchInfo1::GetParameter(invocation), p1);
4118  fetch2.Store(threadIndices, FetchInfo2::GetParameter(invocation), p2);
4119  fetch3.Store(threadIndices, FetchInfo3::GetParameter(invocation), p3);
4120  fetch4.Store(threadIndices, FetchInfo4::GetParameter(invocation), p4);
4121  fetch5.Store(threadIndices, FetchInfo5::GetParameter(invocation), p5);
4122  fetch6.Store(threadIndices, FetchInfo6::GetParameter(invocation), p6);
4123  fetch7.Store(threadIndices, FetchInfo7::GetParameter(invocation), p7);
4124  fetch8.Store(threadIndices, FetchInfo8::GetParameter(invocation), p8);
4125  fetch9.Store(threadIndices, FetchInfo9::GetParameter(invocation), p9);
4126  fetch10.Store(threadIndices, FetchInfo10::GetParameter(invocation), p10);
4127  fetch11.Store(threadIndices, FetchInfo11::GetParameter(invocation), p11);
4128  fetch12.Store(threadIndices, FetchInfo12::GetParameter(invocation), p12);
4129  fetch13.Store(threadIndices, FetchInfo13::GetParameter(invocation), p13);
4130  fetch14.Store(threadIndices, FetchInfo14::GetParameter(invocation), p14);
4131  fetch15.Store(threadIndices, FetchInfo15::GetParameter(invocation), p15);
4132  fetch16.Store(threadIndices, FetchInfo16::GetParameter(invocation), p16);
4133  fetch17.Store(threadIndices, FetchInfo17::GetParameter(invocation), p17);
4134 }
4135 
4136 template <typename WorkletType,
4137  typename ParameterInterface,
4138  typename ControlInterface,
4139  vtkm::IdComponent InputDomainIndex,
4140  typename OutputToInputMapType,
4141  typename VisitArrayType,
4142  typename ThreadToOutputMapType,
4143  typename DeviceAdapterTag,
4144  typename ThreadIndicesType,
4145  typename R,
4146  typename P1,
4147  typename P2,
4148  typename P3,
4149  typename P4,
4150  typename P5,
4151  typename P6,
4152  typename P7,
4153  typename P8,
4154  typename P9,
4155  typename P10,
4156  typename P11,
4157  typename P12,
4158  typename P13,
4159  typename P14,
4160  typename P15,
4161  typename P16,
4162  typename P17,
4163  typename P18>
4164 VTKM_EXEC void DoWorkletInvokeFunctor(
4165  const WorkletType& worklet,
4166  const vtkm::internal::Invocation<ParameterInterface,
4167  ControlInterface,
4168  vtkm::internal::FunctionInterface<R(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18)>,
4169  InputDomainIndex,
4170  OutputToInputMapType,
4171  VisitArrayType,
4172  ThreadToOutputMapType,
4173  DeviceAdapterTag>& invocation,
4174  const ThreadIndicesType& threadIndices)
4175 {
4176  using Invocation = vtkm::internal::Invocation<ParameterInterface,
4177  ControlInterface,
4178  vtkm::internal::FunctionInterface<R(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18)>,
4179  InputDomainIndex,
4180  OutputToInputMapType,
4181  VisitArrayType,
4182  ThreadToOutputMapType,
4183  DeviceAdapterTag>;
4184 
4185  using FetchInfo1 = InvocationToFetch<ThreadIndicesType, Invocation, 1>;
4186  using FetchType1 = typename FetchInfo1::type;
4187  FetchType1 fetch1;
4188  auto p1 =
4189  fetch1.Load(threadIndices, FetchInfo1::GetParameter(invocation));
4190 
4191  using FetchInfo2 = InvocationToFetch<ThreadIndicesType, Invocation, 2>;
4192  using FetchType2 = typename FetchInfo2::type;
4193  FetchType2 fetch2;
4194  auto p2 =
4195  fetch2.Load(threadIndices, FetchInfo2::GetParameter(invocation));
4196 
4197  using FetchInfo3 = InvocationToFetch<ThreadIndicesType, Invocation, 3>;
4198  using FetchType3 = typename FetchInfo3::type;
4199  FetchType3 fetch3;
4200  auto p3 =
4201  fetch3.Load(threadIndices, FetchInfo3::GetParameter(invocation));
4202 
4203  using FetchInfo4 = InvocationToFetch<ThreadIndicesType, Invocation, 4>;
4204  using FetchType4 = typename FetchInfo4::type;
4205  FetchType4 fetch4;
4206  auto p4 =
4207  fetch4.Load(threadIndices, FetchInfo4::GetParameter(invocation));
4208 
4209  using FetchInfo5 = InvocationToFetch<ThreadIndicesType, Invocation, 5>;
4210  using FetchType5 = typename FetchInfo5::type;
4211  FetchType5 fetch5;
4212  auto p5 =
4213  fetch5.Load(threadIndices, FetchInfo5::GetParameter(invocation));
4214 
4215  using FetchInfo6 = InvocationToFetch<ThreadIndicesType, Invocation, 6>;
4216  using FetchType6 = typename FetchInfo6::type;
4217  FetchType6 fetch6;
4218  auto p6 =
4219  fetch6.Load(threadIndices, FetchInfo6::GetParameter(invocation));
4220 
4221  using FetchInfo7 = InvocationToFetch<ThreadIndicesType, Invocation, 7>;
4222  using FetchType7 = typename FetchInfo7::type;
4223  FetchType7 fetch7;
4224  auto p7 =
4225  fetch7.Load(threadIndices, FetchInfo7::GetParameter(invocation));
4226 
4227  using FetchInfo8 = InvocationToFetch<ThreadIndicesType, Invocation, 8>;
4228  using FetchType8 = typename FetchInfo8::type;
4229  FetchType8 fetch8;
4230  auto p8 =
4231  fetch8.Load(threadIndices, FetchInfo8::GetParameter(invocation));
4232 
4233  using FetchInfo9 = InvocationToFetch<ThreadIndicesType, Invocation, 9>;
4234  using FetchType9 = typename FetchInfo9::type;
4235  FetchType9 fetch9;
4236  auto p9 =
4237  fetch9.Load(threadIndices, FetchInfo9::GetParameter(invocation));
4238 
4239  using FetchInfo10 = InvocationToFetch<ThreadIndicesType, Invocation, 10>;
4240  using FetchType10 = typename FetchInfo10::type;
4241  FetchType10 fetch10;
4242  auto p10 =
4243  fetch10.Load(threadIndices, FetchInfo10::GetParameter(invocation));
4244 
4245  using FetchInfo11 = InvocationToFetch<ThreadIndicesType, Invocation, 11>;
4246  using FetchType11 = typename FetchInfo11::type;
4247  FetchType11 fetch11;
4248  auto p11 =
4249  fetch11.Load(threadIndices, FetchInfo11::GetParameter(invocation));
4250 
4251  using FetchInfo12 = InvocationToFetch<ThreadIndicesType, Invocation, 12>;
4252  using FetchType12 = typename FetchInfo12::type;
4253  FetchType12 fetch12;
4254  auto p12 =
4255  fetch12.Load(threadIndices, FetchInfo12::GetParameter(invocation));
4256 
4257  using FetchInfo13 = InvocationToFetch<ThreadIndicesType, Invocation, 13>;
4258  using FetchType13 = typename FetchInfo13::type;
4259  FetchType13 fetch13;
4260  auto p13 =
4261  fetch13.Load(threadIndices, FetchInfo13::GetParameter(invocation));
4262 
4263  using FetchInfo14 = InvocationToFetch<ThreadIndicesType, Invocation, 14>;
4264  using FetchType14 = typename FetchInfo14::type;
4265  FetchType14 fetch14;
4266  auto p14 =
4267  fetch14.Load(threadIndices, FetchInfo14::GetParameter(invocation));
4268 
4269  using FetchInfo15 = InvocationToFetch<ThreadIndicesType, Invocation, 15>;
4270  using FetchType15 = typename FetchInfo15::type;
4271  FetchType15 fetch15;
4272  auto p15 =
4273  fetch15.Load(threadIndices, FetchInfo15::GetParameter(invocation));
4274 
4275  using FetchInfo16 = InvocationToFetch<ThreadIndicesType, Invocation, 16>;
4276  using FetchType16 = typename FetchInfo16::type;
4277  FetchType16 fetch16;
4278  auto p16 =
4279  fetch16.Load(threadIndices, FetchInfo16::GetParameter(invocation));
4280 
4281  using FetchInfo17 = InvocationToFetch<ThreadIndicesType, Invocation, 17>;
4282  using FetchType17 = typename FetchInfo17::type;
4283  FetchType17 fetch17;
4284  auto p17 =
4285  fetch17.Load(threadIndices, FetchInfo17::GetParameter(invocation));
4286 
4287  using FetchInfo18 = InvocationToFetch<ThreadIndicesType, Invocation, 18>;
4288  using FetchType18 = typename FetchInfo18::type;
4289  FetchType18 fetch18;
4290  auto p18 =
4291  fetch18.Load(threadIndices, FetchInfo18::GetParameter(invocation));
4292 
4293  using FetchInfo0 = InvocationToFetch<ThreadIndicesType, Invocation, 0>;
4294  using ReturnFetchType = typename FetchInfo0::type;
4295  ReturnFetchType returnFetch;
4296  // If you got a compile error on the following line, it probably means that
4297  // the operator() of a worklet does not match the definition expected. One
4298  // common problem is that the operator() method must be declared const. Check
4299  // to make sure the "const" keyword is after parameters. Another common
4300  // problem is that the type of one or more parameters is incompatible with
4301  // the actual type that VTK-m creates in the execution environment. Make sure
4302  // that the types of the worklet operator() parameters match those in the
4303  // ExecutionSignature. The compiler error might help you narrow down which
4304  // parameter is wrong and the types that did not match.
4305  auto r = worklet(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18);
4306 
4307  fetch1.Store(threadIndices, FetchInfo1::GetParameter(invocation), p1);
4308  fetch2.Store(threadIndices, FetchInfo2::GetParameter(invocation), p2);
4309  fetch3.Store(threadIndices, FetchInfo3::GetParameter(invocation), p3);
4310  fetch4.Store(threadIndices, FetchInfo4::GetParameter(invocation), p4);
4311  fetch5.Store(threadIndices, FetchInfo5::GetParameter(invocation), p5);
4312  fetch6.Store(threadIndices, FetchInfo6::GetParameter(invocation), p6);
4313  fetch7.Store(threadIndices, FetchInfo7::GetParameter(invocation), p7);
4314  fetch8.Store(threadIndices, FetchInfo8::GetParameter(invocation), p8);
4315  fetch9.Store(threadIndices, FetchInfo9::GetParameter(invocation), p9);
4316  fetch10.Store(threadIndices, FetchInfo10::GetParameter(invocation), p10);
4317  fetch11.Store(threadIndices, FetchInfo11::GetParameter(invocation), p11);
4318  fetch12.Store(threadIndices, FetchInfo12::GetParameter(invocation), p12);
4319  fetch13.Store(threadIndices, FetchInfo13::GetParameter(invocation), p13);
4320  fetch14.Store(threadIndices, FetchInfo14::GetParameter(invocation), p14);
4321  fetch15.Store(threadIndices, FetchInfo15::GetParameter(invocation), p15);
4322  fetch16.Store(threadIndices, FetchInfo16::GetParameter(invocation), p16);
4323  fetch17.Store(threadIndices, FetchInfo17::GetParameter(invocation), p17);
4324  fetch18.Store(threadIndices, FetchInfo18::GetParameter(invocation), p18);
4325 
4326  returnFetch.Store(threadIndices, FetchInfo0::GetParameter(invocation), r);
4327 }
4328 
4329 template <typename WorkletType,
4330  typename ParameterInterface,
4331  typename ControlInterface,
4332  vtkm::IdComponent InputDomainIndex,
4333  typename OutputToInputMapType,
4334  typename VisitArrayType,
4335  typename ThreadToOutputMapType,
4336  typename DeviceAdapterTag,
4337  typename ThreadIndicesType,
4338  typename P1,
4339  typename P2,
4340  typename P3,
4341  typename P4,
4342  typename P5,
4343  typename P6,
4344  typename P7,
4345  typename P8,
4346  typename P9,
4347  typename P10,
4348  typename P11,
4349  typename P12,
4350  typename P13,
4351  typename P14,
4352  typename P15,
4353  typename P16,
4354  typename P17,
4355  typename P18>
4356 VTKM_EXEC void DoWorkletInvokeFunctor(
4357  const WorkletType& worklet,
4358  const vtkm::internal::Invocation<ParameterInterface,
4359  ControlInterface,
4360  vtkm::internal::FunctionInterface<void(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18)>,
4361  InputDomainIndex,
4362  OutputToInputMapType,
4363  VisitArrayType,
4364  ThreadToOutputMapType,
4365  DeviceAdapterTag>& invocation,
4366  const ThreadIndicesType& threadIndices)
4367 {
4368  using Invocation =
4369  vtkm::internal::Invocation<ParameterInterface,
4370  ControlInterface,
4371  vtkm::internal::FunctionInterface<void(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18)>,
4372  InputDomainIndex,
4373  OutputToInputMapType,
4374  VisitArrayType,
4375  ThreadToOutputMapType,
4376  DeviceAdapterTag>;
4377 
4378  using FetchInfo1 = InvocationToFetch<ThreadIndicesType, Invocation, 1>;
4379  using FetchType1 = typename FetchInfo1::type;
4380  FetchType1 fetch1;
4381  auto p1 =
4382  fetch1.Load(threadIndices, FetchInfo1::GetParameter(invocation));
4383 
4384  using FetchInfo2 = InvocationToFetch<ThreadIndicesType, Invocation, 2>;
4385  using FetchType2 = typename FetchInfo2::type;
4386  FetchType2 fetch2;
4387  auto p2 =
4388  fetch2.Load(threadIndices, FetchInfo2::GetParameter(invocation));
4389 
4390  using FetchInfo3 = InvocationToFetch<ThreadIndicesType, Invocation, 3>;
4391  using FetchType3 = typename FetchInfo3::type;
4392  FetchType3 fetch3;
4393  auto p3 =
4394  fetch3.Load(threadIndices, FetchInfo3::GetParameter(invocation));
4395 
4396  using FetchInfo4 = InvocationToFetch<ThreadIndicesType, Invocation, 4>;
4397  using FetchType4 = typename FetchInfo4::type;
4398  FetchType4 fetch4;
4399  auto p4 =
4400  fetch4.Load(threadIndices, FetchInfo4::GetParameter(invocation));
4401 
4402  using FetchInfo5 = InvocationToFetch<ThreadIndicesType, Invocation, 5>;
4403  using FetchType5 = typename FetchInfo5::type;
4404  FetchType5 fetch5;
4405  auto p5 =
4406  fetch5.Load(threadIndices, FetchInfo5::GetParameter(invocation));
4407 
4408  using FetchInfo6 = InvocationToFetch<ThreadIndicesType, Invocation, 6>;
4409  using FetchType6 = typename FetchInfo6::type;
4410  FetchType6 fetch6;
4411  auto p6 =
4412  fetch6.Load(threadIndices, FetchInfo6::GetParameter(invocation));
4413 
4414  using FetchInfo7 = InvocationToFetch<ThreadIndicesType, Invocation, 7>;
4415  using FetchType7 = typename FetchInfo7::type;
4416  FetchType7 fetch7;
4417  auto p7 =
4418  fetch7.Load(threadIndices, FetchInfo7::GetParameter(invocation));
4419 
4420  using FetchInfo8 = InvocationToFetch<ThreadIndicesType, Invocation, 8>;
4421  using FetchType8 = typename FetchInfo8::type;
4422  FetchType8 fetch8;
4423  auto p8 =
4424  fetch8.Load(threadIndices, FetchInfo8::GetParameter(invocation));
4425 
4426  using FetchInfo9 = InvocationToFetch<ThreadIndicesType, Invocation, 9>;
4427  using FetchType9 = typename FetchInfo9::type;
4428  FetchType9 fetch9;
4429  auto p9 =
4430  fetch9.Load(threadIndices, FetchInfo9::GetParameter(invocation));
4431 
4432  using FetchInfo10 = InvocationToFetch<ThreadIndicesType, Invocation, 10>;
4433  using FetchType10 = typename FetchInfo10::type;
4434  FetchType10 fetch10;
4435  auto p10 =
4436  fetch10.Load(threadIndices, FetchInfo10::GetParameter(invocation));
4437 
4438  using FetchInfo11 = InvocationToFetch<ThreadIndicesType, Invocation, 11>;
4439  using FetchType11 = typename FetchInfo11::type;
4440  FetchType11 fetch11;
4441  auto p11 =
4442  fetch11.Load(threadIndices, FetchInfo11::GetParameter(invocation));
4443 
4444  using FetchInfo12 = InvocationToFetch<ThreadIndicesType, Invocation, 12>;
4445  using FetchType12 = typename FetchInfo12::type;
4446  FetchType12 fetch12;
4447  auto p12 =
4448  fetch12.Load(threadIndices, FetchInfo12::GetParameter(invocation));
4449 
4450  using FetchInfo13 = InvocationToFetch<ThreadIndicesType, Invocation, 13>;
4451  using FetchType13 = typename FetchInfo13::type;
4452  FetchType13 fetch13;
4453  auto p13 =
4454  fetch13.Load(threadIndices, FetchInfo13::GetParameter(invocation));
4455 
4456  using FetchInfo14 = InvocationToFetch<ThreadIndicesType, Invocation, 14>;
4457  using FetchType14 = typename FetchInfo14::type;
4458  FetchType14 fetch14;
4459  auto p14 =
4460  fetch14.Load(threadIndices, FetchInfo14::GetParameter(invocation));
4461 
4462  using FetchInfo15 = InvocationToFetch<ThreadIndicesType, Invocation, 15>;
4463  using FetchType15 = typename FetchInfo15::type;
4464  FetchType15 fetch15;
4465  auto p15 =
4466  fetch15.Load(threadIndices, FetchInfo15::GetParameter(invocation));
4467 
4468  using FetchInfo16 = InvocationToFetch<ThreadIndicesType, Invocation, 16>;
4469  using FetchType16 = typename FetchInfo16::type;
4470  FetchType16 fetch16;
4471  auto p16 =
4472  fetch16.Load(threadIndices, FetchInfo16::GetParameter(invocation));
4473 
4474  using FetchInfo17 = InvocationToFetch<ThreadIndicesType, Invocation, 17>;
4475  using FetchType17 = typename FetchInfo17::type;
4476  FetchType17 fetch17;
4477  auto p17 =
4478  fetch17.Load(threadIndices, FetchInfo17::GetParameter(invocation));
4479 
4480  using FetchInfo18 = InvocationToFetch<ThreadIndicesType, Invocation, 18>;
4481  using FetchType18 = typename FetchInfo18::type;
4482  FetchType18 fetch18;
4483  auto p18 =
4484  fetch18.Load(threadIndices, FetchInfo18::GetParameter(invocation));
4485 
4486  // If you got a compile error on the following line, it probably means that
4487  // the operator() of a worklet does not match the definition expected. One
4488  // common problem is that the operator() method must be declared const. Check
4489  // to make sure the "const" keyword is after parameters. Another common
4490  // problem is that the type of one or more parameters is incompatible with
4491  // the actual type that VTK-m creates in the execution environment. Make sure
4492  // that the types of the worklet operator() parameters match those in the
4493  // ExecutionSignature. The compiler error might help you narrow down which
4494  // parameter is wrong and the types that did not match.
4495  worklet(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18);
4496 
4497  fetch1.Store(threadIndices, FetchInfo1::GetParameter(invocation), p1);
4498  fetch2.Store(threadIndices, FetchInfo2::GetParameter(invocation), p2);
4499  fetch3.Store(threadIndices, FetchInfo3::GetParameter(invocation), p3);
4500  fetch4.Store(threadIndices, FetchInfo4::GetParameter(invocation), p4);
4501  fetch5.Store(threadIndices, FetchInfo5::GetParameter(invocation), p5);
4502  fetch6.Store(threadIndices, FetchInfo6::GetParameter(invocation), p6);
4503  fetch7.Store(threadIndices, FetchInfo7::GetParameter(invocation), p7);
4504  fetch8.Store(threadIndices, FetchInfo8::GetParameter(invocation), p8);
4505  fetch9.Store(threadIndices, FetchInfo9::GetParameter(invocation), p9);
4506  fetch10.Store(threadIndices, FetchInfo10::GetParameter(invocation), p10);
4507  fetch11.Store(threadIndices, FetchInfo11::GetParameter(invocation), p11);
4508  fetch12.Store(threadIndices, FetchInfo12::GetParameter(invocation), p12);
4509  fetch13.Store(threadIndices, FetchInfo13::GetParameter(invocation), p13);
4510  fetch14.Store(threadIndices, FetchInfo14::GetParameter(invocation), p14);
4511  fetch15.Store(threadIndices, FetchInfo15::GetParameter(invocation), p15);
4512  fetch16.Store(threadIndices, FetchInfo16::GetParameter(invocation), p16);
4513  fetch17.Store(threadIndices, FetchInfo17::GetParameter(invocation), p17);
4514  fetch18.Store(threadIndices, FetchInfo18::GetParameter(invocation), p18);
4515 }
4516 
4517 template <typename WorkletType,
4518  typename ParameterInterface,
4519  typename ControlInterface,
4520  vtkm::IdComponent InputDomainIndex,
4521  typename OutputToInputMapType,
4522  typename VisitArrayType,
4523  typename ThreadToOutputMapType,
4524  typename DeviceAdapterTag,
4525  typename ThreadIndicesType,
4526  typename R,
4527  typename P1,
4528  typename P2,
4529  typename P3,
4530  typename P4,
4531  typename P5,
4532  typename P6,
4533  typename P7,
4534  typename P8,
4535  typename P9,
4536  typename P10,
4537  typename P11,
4538  typename P12,
4539  typename P13,
4540  typename P14,
4541  typename P15,
4542  typename P16,
4543  typename P17,
4544  typename P18,
4545  typename P19>
4546 VTKM_EXEC void DoWorkletInvokeFunctor(
4547  const WorkletType& worklet,
4548  const vtkm::internal::Invocation<ParameterInterface,
4549  ControlInterface,
4550  vtkm::internal::FunctionInterface<R(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19)>,
4551  InputDomainIndex,
4552  OutputToInputMapType,
4553  VisitArrayType,
4554  ThreadToOutputMapType,
4555  DeviceAdapterTag>& invocation,
4556  const ThreadIndicesType& threadIndices)
4557 {
4558  using Invocation = vtkm::internal::Invocation<ParameterInterface,
4559  ControlInterface,
4560  vtkm::internal::FunctionInterface<R(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19)>,
4561  InputDomainIndex,
4562  OutputToInputMapType,
4563  VisitArrayType,
4564  ThreadToOutputMapType,
4565  DeviceAdapterTag>;
4566 
4567  using FetchInfo1 = InvocationToFetch<ThreadIndicesType, Invocation, 1>;
4568  using FetchType1 = typename FetchInfo1::type;
4569  FetchType1 fetch1;
4570  auto p1 =
4571  fetch1.Load(threadIndices, FetchInfo1::GetParameter(invocation));
4572 
4573  using FetchInfo2 = InvocationToFetch<ThreadIndicesType, Invocation, 2>;
4574  using FetchType2 = typename FetchInfo2::type;
4575  FetchType2 fetch2;
4576  auto p2 =
4577  fetch2.Load(threadIndices, FetchInfo2::GetParameter(invocation));
4578 
4579  using FetchInfo3 = InvocationToFetch<ThreadIndicesType, Invocation, 3>;
4580  using FetchType3 = typename FetchInfo3::type;
4581  FetchType3 fetch3;
4582  auto p3 =
4583  fetch3.Load(threadIndices, FetchInfo3::GetParameter(invocation));
4584 
4585  using FetchInfo4 = InvocationToFetch<ThreadIndicesType, Invocation, 4>;
4586  using FetchType4 = typename FetchInfo4::type;
4587  FetchType4 fetch4;
4588  auto p4 =
4589  fetch4.Load(threadIndices, FetchInfo4::GetParameter(invocation));
4590 
4591  using FetchInfo5 = InvocationToFetch<ThreadIndicesType, Invocation, 5>;
4592  using FetchType5 = typename FetchInfo5::type;
4593  FetchType5 fetch5;
4594  auto p5 =
4595  fetch5.Load(threadIndices, FetchInfo5::GetParameter(invocation));
4596 
4597  using FetchInfo6 = InvocationToFetch<ThreadIndicesType, Invocation, 6>;
4598  using FetchType6 = typename FetchInfo6::type;
4599  FetchType6 fetch6;
4600  auto p6 =
4601  fetch6.Load(threadIndices, FetchInfo6::GetParameter(invocation));
4602 
4603  using FetchInfo7 = InvocationToFetch<ThreadIndicesType, Invocation, 7>;
4604  using FetchType7 = typename FetchInfo7::type;
4605  FetchType7 fetch7;
4606  auto p7 =
4607  fetch7.Load(threadIndices, FetchInfo7::GetParameter(invocation));
4608 
4609  using FetchInfo8 = InvocationToFetch<ThreadIndicesType, Invocation, 8>;
4610  using FetchType8 = typename FetchInfo8::type;
4611  FetchType8 fetch8;
4612  auto p8 =
4613  fetch8.Load(threadIndices, FetchInfo8::GetParameter(invocation));
4614 
4615  using FetchInfo9 = InvocationToFetch<ThreadIndicesType, Invocation, 9>;
4616  using FetchType9 = typename FetchInfo9::type;
4617  FetchType9 fetch9;
4618  auto p9 =
4619  fetch9.Load(threadIndices, FetchInfo9::GetParameter(invocation));
4620 
4621  using FetchInfo10 = InvocationToFetch<ThreadIndicesType, Invocation, 10>;
4622  using FetchType10 = typename FetchInfo10::type;
4623  FetchType10 fetch10;
4624  auto p10 =
4625  fetch10.Load(threadIndices, FetchInfo10::GetParameter(invocation));
4626 
4627  using FetchInfo11 = InvocationToFetch<ThreadIndicesType, Invocation, 11>;
4628  using FetchType11 = typename FetchInfo11::type;
4629  FetchType11 fetch11;
4630  auto p11 =
4631  fetch11.Load(threadIndices, FetchInfo11::GetParameter(invocation));
4632 
4633  using FetchInfo12 = InvocationToFetch<ThreadIndicesType, Invocation, 12>;
4634  using FetchType12 = typename FetchInfo12::type;
4635  FetchType12 fetch12;
4636  auto p12 =
4637  fetch12.Load(threadIndices, FetchInfo12::GetParameter(invocation));
4638 
4639  using FetchInfo13 = InvocationToFetch<ThreadIndicesType, Invocation, 13>;
4640  using FetchType13 = typename FetchInfo13::type;
4641  FetchType13 fetch13;
4642  auto p13 =
4643  fetch13.Load(threadIndices, FetchInfo13::GetParameter(invocation));
4644 
4645  using FetchInfo14 = InvocationToFetch<ThreadIndicesType, Invocation, 14>;
4646  using FetchType14 = typename FetchInfo14::type;
4647  FetchType14 fetch14;
4648  auto p14 =
4649  fetch14.Load(threadIndices, FetchInfo14::GetParameter(invocation));
4650 
4651  using FetchInfo15 = InvocationToFetch<ThreadIndicesType, Invocation, 15>;
4652  using FetchType15 = typename FetchInfo15::type;
4653  FetchType15 fetch15;
4654  auto p15 =
4655  fetch15.Load(threadIndices, FetchInfo15::GetParameter(invocation));
4656 
4657  using FetchInfo16 = InvocationToFetch<ThreadIndicesType, Invocation, 16>;
4658  using FetchType16 = typename FetchInfo16::type;
4659  FetchType16 fetch16;
4660  auto p16 =
4661  fetch16.Load(threadIndices, FetchInfo16::GetParameter(invocation));
4662 
4663  using FetchInfo17 = InvocationToFetch<ThreadIndicesType, Invocation, 17>;
4664  using FetchType17 = typename FetchInfo17::type;
4665  FetchType17 fetch17;
4666  auto p17 =
4667  fetch17.Load(threadIndices, FetchInfo17::GetParameter(invocation));
4668 
4669  using FetchInfo18 = InvocationToFetch<ThreadIndicesType, Invocation, 18>;
4670  using FetchType18 = typename FetchInfo18::type;
4671  FetchType18 fetch18;
4672  auto p18 =
4673  fetch18.Load(threadIndices, FetchInfo18::GetParameter(invocation));
4674 
4675  using FetchInfo19 = InvocationToFetch<ThreadIndicesType, Invocation, 19>;
4676  using FetchType19 = typename FetchInfo19::type;
4677  FetchType19 fetch19;
4678  auto p19 =
4679  fetch19.Load(threadIndices, FetchInfo19::GetParameter(invocation));
4680 
4681  using FetchInfo0 = InvocationToFetch<ThreadIndicesType, Invocation, 0>;
4682  using ReturnFetchType = typename FetchInfo0::type;
4683  ReturnFetchType returnFetch;
4684  // If you got a compile error on the following line, it probably means that
4685  // the operator() of a worklet does not match the definition expected. One
4686  // common problem is that the operator() method must be declared const. Check
4687  // to make sure the "const" keyword is after parameters. Another common
4688  // problem is that the type of one or more parameters is incompatible with
4689  // the actual type that VTK-m creates in the execution environment. Make sure
4690  // that the types of the worklet operator() parameters match those in the
4691  // ExecutionSignature. The compiler error might help you narrow down which
4692  // parameter is wrong and the types that did not match.
4693  auto r = worklet(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19);
4694 
4695  fetch1.Store(threadIndices, FetchInfo1::GetParameter(invocation), p1);
4696  fetch2.Store(threadIndices, FetchInfo2::GetParameter(invocation), p2);
4697  fetch3.Store(threadIndices, FetchInfo3::GetParameter(invocation), p3);
4698  fetch4.Store(threadIndices, FetchInfo4::GetParameter(invocation), p4);
4699  fetch5.Store(threadIndices, FetchInfo5::GetParameter(invocation), p5);
4700  fetch6.Store(threadIndices, FetchInfo6::GetParameter(invocation), p6);
4701  fetch7.Store(threadIndices, FetchInfo7::GetParameter(invocation), p7);
4702  fetch8.Store(threadIndices, FetchInfo8::GetParameter(invocation), p8);
4703  fetch9.Store(threadIndices, FetchInfo9::GetParameter(invocation), p9);
4704  fetch10.Store(threadIndices, FetchInfo10::GetParameter(invocation), p10);
4705  fetch11.Store(threadIndices, FetchInfo11::GetParameter(invocation), p11);
4706  fetch12.Store(threadIndices, FetchInfo12::GetParameter(invocation), p12);
4707  fetch13.Store(threadIndices, FetchInfo13::GetParameter(invocation), p13);
4708  fetch14.Store(threadIndices, FetchInfo14::GetParameter(invocation), p14);
4709  fetch15.Store(threadIndices, FetchInfo15::GetParameter(invocation), p15);
4710  fetch16.Store(threadIndices, FetchInfo16::GetParameter(invocation), p16);
4711  fetch17.Store(threadIndices, FetchInfo17::GetParameter(invocation), p17);
4712  fetch18.Store(threadIndices, FetchInfo18::GetParameter(invocation), p18);
4713  fetch19.Store(threadIndices, FetchInfo19::GetParameter(invocation), p19);
4714 
4715  returnFetch.Store(threadIndices, FetchInfo0::GetParameter(invocation), r);
4716 }
4717 
4718 template <typename WorkletType,
4719  typename ParameterInterface,
4720  typename ControlInterface,
4721  vtkm::IdComponent InputDomainIndex,
4722  typename OutputToInputMapType,
4723  typename VisitArrayType,
4724  typename ThreadToOutputMapType,
4725  typename DeviceAdapterTag,
4726  typename ThreadIndicesType,
4727  typename P1,
4728  typename P2,
4729  typename P3,
4730  typename P4,
4731  typename P5,
4732  typename P6,
4733  typename P7,
4734  typename P8,
4735  typename P9,
4736  typename P10,
4737  typename P11,
4738  typename P12,
4739  typename P13,
4740  typename P14,
4741  typename P15,
4742  typename P16,
4743  typename P17,
4744  typename P18,
4745  typename P19>
4746 VTKM_EXEC void DoWorkletInvokeFunctor(
4747  const WorkletType& worklet,
4748  const vtkm::internal::Invocation<ParameterInterface,
4749  ControlInterface,
4750  vtkm::internal::FunctionInterface<void(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19)>,
4751  InputDomainIndex,
4752  OutputToInputMapType,
4753  VisitArrayType,
4754  ThreadToOutputMapType,
4755  DeviceAdapterTag>& invocation,
4756  const ThreadIndicesType& threadIndices)
4757 {
4758  using Invocation =
4759  vtkm::internal::Invocation<ParameterInterface,
4760  ControlInterface,
4761  vtkm::internal::FunctionInterface<void(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19)>,
4762  InputDomainIndex,
4763  OutputToInputMapType,
4764  VisitArrayType,
4765  ThreadToOutputMapType,
4766  DeviceAdapterTag>;
4767 
4768  using FetchInfo1 = InvocationToFetch<ThreadIndicesType, Invocation, 1>;
4769  using FetchType1 = typename FetchInfo1::type;
4770  FetchType1 fetch1;
4771  auto p1 =
4772  fetch1.Load(threadIndices, FetchInfo1::GetParameter(invocation));
4773 
4774  using FetchInfo2 = InvocationToFetch<ThreadIndicesType, Invocation, 2>;
4775  using FetchType2 = typename FetchInfo2::type;
4776  FetchType2 fetch2;
4777  auto p2 =
4778  fetch2.Load(threadIndices, FetchInfo2::GetParameter(invocation));
4779 
4780  using FetchInfo3 = InvocationToFetch<ThreadIndicesType, Invocation, 3>;
4781  using FetchType3 = typename FetchInfo3::type;
4782  FetchType3 fetch3;
4783  auto p3 =
4784  fetch3.Load(threadIndices, FetchInfo3::GetParameter(invocation));
4785 
4786  using FetchInfo4 = InvocationToFetch<ThreadIndicesType, Invocation, 4>;
4787  using FetchType4 = typename FetchInfo4::type;
4788  FetchType4 fetch4;
4789  auto p4 =
4790  fetch4.Load(threadIndices, FetchInfo4::GetParameter(invocation));
4791 
4792  using FetchInfo5 = InvocationToFetch<ThreadIndicesType, Invocation, 5>;
4793  using FetchType5 = typename FetchInfo5::type;
4794  FetchType5 fetch5;
4795  auto p5 =
4796  fetch5.Load(threadIndices, FetchInfo5::GetParameter(invocation));
4797 
4798  using FetchInfo6 = InvocationToFetch<ThreadIndicesType, Invocation, 6>;
4799  using FetchType6 = typename FetchInfo6::type;
4800  FetchType6 fetch6;
4801  auto p6 =
4802  fetch6.Load(threadIndices, FetchInfo6::GetParameter(invocation));
4803 
4804  using FetchInfo7 = InvocationToFetch<ThreadIndicesType, Invocation, 7>;
4805  using FetchType7 = typename FetchInfo7::type;
4806  FetchType7 fetch7;
4807  auto p7 =
4808  fetch7.Load(threadIndices, FetchInfo7::GetParameter(invocation));
4809 
4810  using FetchInfo8 = InvocationToFetch<ThreadIndicesType, Invocation, 8>;
4811  using FetchType8 = typename FetchInfo8::type;
4812  FetchType8 fetch8;
4813  auto p8 =
4814  fetch8.Load(threadIndices, FetchInfo8::GetParameter(invocation));
4815 
4816  using FetchInfo9 = InvocationToFetch<ThreadIndicesType, Invocation, 9>;
4817  using FetchType9 = typename FetchInfo9::type;
4818  FetchType9 fetch9;
4819  auto p9 =
4820  fetch9.Load(threadIndices, FetchInfo9::GetParameter(invocation));
4821 
4822  using FetchInfo10 = InvocationToFetch<ThreadIndicesType, Invocation, 10>;
4823  using FetchType10 = typename FetchInfo10::type;
4824  FetchType10 fetch10;
4825  auto p10 =
4826  fetch10.Load(threadIndices, FetchInfo10::GetParameter(invocation));
4827 
4828  using FetchInfo11 = InvocationToFetch<ThreadIndicesType, Invocation, 11>;
4829  using FetchType11 = typename FetchInfo11::type;
4830  FetchType11 fetch11;
4831  auto p11 =
4832  fetch11.Load(threadIndices, FetchInfo11::GetParameter(invocation));
4833 
4834  using FetchInfo12 = InvocationToFetch<ThreadIndicesType, Invocation, 12>;
4835  using FetchType12 = typename FetchInfo12::type;
4836  FetchType12 fetch12;
4837  auto p12 =
4838  fetch12.Load(threadIndices, FetchInfo12::GetParameter(invocation));
4839 
4840  using FetchInfo13 = InvocationToFetch<ThreadIndicesType, Invocation, 13>;
4841  using FetchType13 = typename FetchInfo13::type;
4842  FetchType13 fetch13;
4843  auto p13 =
4844  fetch13.Load(threadIndices, FetchInfo13::GetParameter(invocation));
4845 
4846  using FetchInfo14 = InvocationToFetch<ThreadIndicesType, Invocation, 14>;
4847  using FetchType14 = typename FetchInfo14::type;
4848  FetchType14 fetch14;
4849  auto p14 =
4850  fetch14.Load(threadIndices, FetchInfo14::GetParameter(invocation));
4851 
4852  using FetchInfo15 = InvocationToFetch<ThreadIndicesType, Invocation, 15>;
4853  using FetchType15 = typename FetchInfo15::type;
4854  FetchType15 fetch15;
4855  auto p15 =
4856  fetch15.Load(threadIndices, FetchInfo15::GetParameter(invocation));
4857 
4858  using FetchInfo16 = InvocationToFetch<ThreadIndicesType, Invocation, 16>;
4859  using FetchType16 = typename FetchInfo16::type;
4860  FetchType16 fetch16;
4861  auto p16 =
4862  fetch16.Load(threadIndices, FetchInfo16::GetParameter(invocation));
4863 
4864  using FetchInfo17 = InvocationToFetch<ThreadIndicesType, Invocation, 17>;
4865  using FetchType17 = typename FetchInfo17::type;
4866  FetchType17 fetch17;
4867  auto p17 =
4868  fetch17.Load(threadIndices, FetchInfo17::GetParameter(invocation));
4869 
4870  using FetchInfo18 = InvocationToFetch<ThreadIndicesType, Invocation, 18>;
4871  using FetchType18 = typename FetchInfo18::type;
4872  FetchType18 fetch18;
4873  auto p18 =
4874  fetch18.Load(threadIndices, FetchInfo18::GetParameter(invocation));
4875 
4876  using FetchInfo19 = InvocationToFetch<ThreadIndicesType, Invocation, 19>;
4877  using FetchType19 = typename FetchInfo19::type;
4878  FetchType19 fetch19;
4879  auto p19 =
4880  fetch19.Load(threadIndices, FetchInfo19::GetParameter(invocation));
4881 
4882  // If you got a compile error on the following line, it probably means that
4883  // the operator() of a worklet does not match the definition expected. One
4884  // common problem is that the operator() method must be declared const. Check
4885  // to make sure the "const" keyword is after parameters. Another common
4886  // problem is that the type of one or more parameters is incompatible with
4887  // the actual type that VTK-m creates in the execution environment. Make sure
4888  // that the types of the worklet operator() parameters match those in the
4889  // ExecutionSignature. The compiler error might help you narrow down which
4890  // parameter is wrong and the types that did not match.
4891  worklet(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19);
4892 
4893  fetch1.Store(threadIndices, FetchInfo1::GetParameter(invocation), p1);
4894  fetch2.Store(threadIndices, FetchInfo2::GetParameter(invocation), p2);
4895  fetch3.Store(threadIndices, FetchInfo3::GetParameter(invocation), p3);
4896  fetch4.Store(threadIndices, FetchInfo4::GetParameter(invocation), p4);
4897  fetch5.Store(threadIndices, FetchInfo5::GetParameter(invocation), p5);
4898  fetch6.Store(threadIndices, FetchInfo6::GetParameter(invocation), p6);
4899  fetch7.Store(threadIndices, FetchInfo7::GetParameter(invocation), p7);
4900  fetch8.Store(threadIndices, FetchInfo8::GetParameter(invocation), p8);
4901  fetch9.Store(threadIndices, FetchInfo9::GetParameter(invocation), p9);
4902  fetch10.Store(threadIndices, FetchInfo10::GetParameter(invocation), p10);
4903  fetch11.Store(threadIndices, FetchInfo11::GetParameter(invocation), p11);
4904  fetch12.Store(threadIndices, FetchInfo12::GetParameter(invocation), p12);
4905  fetch13.Store(threadIndices, FetchInfo13::GetParameter(invocation), p13);
4906  fetch14.Store(threadIndices, FetchInfo14::GetParameter(invocation), p14);
4907  fetch15.Store(threadIndices, FetchInfo15::GetParameter(invocation), p15);
4908  fetch16.Store(threadIndices, FetchInfo16::GetParameter(invocation), p16);
4909  fetch17.Store(threadIndices, FetchInfo17::GetParameter(invocation), p17);
4910  fetch18.Store(threadIndices, FetchInfo18::GetParameter(invocation), p18);
4911  fetch19.Store(threadIndices, FetchInfo19::GetParameter(invocation), p19);
4912 }
4913 
4914 template <typename WorkletType,
4915  typename ParameterInterface,
4916  typename ControlInterface,
4917  vtkm::IdComponent InputDomainIndex,
4918  typename OutputToInputMapType,
4919  typename VisitArrayType,
4920  typename ThreadToOutputMapType,
4921  typename DeviceAdapterTag,
4922  typename ThreadIndicesType,
4923  typename R,
4924  typename P1,
4925  typename P2,
4926  typename P3,
4927  typename P4,
4928  typename P5,
4929  typename P6,
4930  typename P7,
4931  typename P8,
4932  typename P9,
4933  typename P10,
4934  typename P11,
4935  typename P12,
4936  typename P13,
4937  typename P14,
4938  typename P15,
4939  typename P16,
4940  typename P17,
4941  typename P18,
4942  typename P19,
4943  typename P20>
4944 VTKM_EXEC void DoWorkletInvokeFunctor(
4945  const WorkletType& worklet,
4946  const vtkm::internal::Invocation<ParameterInterface,
4947  ControlInterface,
4948  vtkm::internal::FunctionInterface<R(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20)>,
4949  InputDomainIndex,
4950  OutputToInputMapType,
4951  VisitArrayType,
4952  ThreadToOutputMapType,
4953  DeviceAdapterTag>& invocation,
4954  const ThreadIndicesType& threadIndices)
4955 {
4956  using Invocation = vtkm::internal::Invocation<ParameterInterface,
4957  ControlInterface,
4958  vtkm::internal::FunctionInterface<R(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20)>,
4959  InputDomainIndex,
4960  OutputToInputMapType,
4961  VisitArrayType,
4962  ThreadToOutputMapType,
4963  DeviceAdapterTag>;
4964 
4965  using FetchInfo1 = InvocationToFetch<ThreadIndicesType, Invocation, 1>;
4966  using FetchType1 = typename FetchInfo1::type;
4967  FetchType1 fetch1;
4968  auto p1 =
4969  fetch1.Load(threadIndices, FetchInfo1::GetParameter(invocation));
4970 
4971  using FetchInfo2 = InvocationToFetch<ThreadIndicesType, Invocation, 2>;
4972  using FetchType2 = typename FetchInfo2::type;
4973  FetchType2 fetch2;
4974  auto p2 =
4975  fetch2.Load(threadIndices, FetchInfo2::GetParameter(invocation));
4976 
4977  using FetchInfo3 = InvocationToFetch<ThreadIndicesType, Invocation, 3>;
4978  using FetchType3 = typename FetchInfo3::type;
4979  FetchType3 fetch3;
4980  auto p3 =
4981  fetch3.Load(threadIndices, FetchInfo3::GetParameter(invocation));
4982 
4983  using FetchInfo4 = InvocationToFetch<ThreadIndicesType, Invocation, 4>;
4984  using FetchType4 = typename FetchInfo4::type;
4985  FetchType4 fetch4;
4986  auto p4 =
4987  fetch4.Load(threadIndices, FetchInfo4::GetParameter(invocation));
4988 
4989  using FetchInfo5 = InvocationToFetch<ThreadIndicesType, Invocation, 5>;
4990  using FetchType5 = typename FetchInfo5::type;
4991  FetchType5 fetch5;
4992  auto p5 =
4993  fetch5.Load(threadIndices, FetchInfo5::GetParameter(invocation));
4994 
4995  using FetchInfo6 = InvocationToFetch<ThreadIndicesType, Invocation, 6>;
4996  using FetchType6 = typename FetchInfo6::type;
4997  FetchType6 fetch6;
4998  auto p6 =
4999  fetch6.Load(threadIndices, FetchInfo6::GetParameter(invocation));
5000 
5001  using FetchInfo7 = InvocationToFetch<ThreadIndicesType, Invocation, 7>;
5002  using FetchType7 = typename FetchInfo7::type;
5003  FetchType7 fetch7;
5004  auto p7 =
5005  fetch7.Load(threadIndices, FetchInfo7::GetParameter(invocation));
5006 
5007  using FetchInfo8 = InvocationToFetch<ThreadIndicesType, Invocation, 8>;
5008  using FetchType8 = typename FetchInfo8::type;
5009  FetchType8 fetch8;
5010  auto p8 =
5011  fetch8.Load(threadIndices, FetchInfo8::GetParameter(invocation));
5012 
5013  using FetchInfo9 = InvocationToFetch<ThreadIndicesType, Invocation, 9>;
5014  using FetchType9 = typename FetchInfo9::type;
5015  FetchType9 fetch9;
5016  auto p9 =
5017  fetch9.Load(threadIndices, FetchInfo9::GetParameter(invocation));
5018 
5019  using FetchInfo10 = InvocationToFetch<ThreadIndicesType, Invocation, 10>;
5020  using FetchType10 = typename FetchInfo10::type;
5021  FetchType10 fetch10;
5022  auto p10 =
5023  fetch10.Load(threadIndices, FetchInfo10::GetParameter(invocation));
5024 
5025  using FetchInfo11 = InvocationToFetch<ThreadIndicesType, Invocation, 11>;
5026  using FetchType11 = typename FetchInfo11::type;
5027  FetchType11 fetch11;
5028  auto p11 =
5029  fetch11.Load(threadIndices, FetchInfo11::GetParameter(invocation));
5030 
5031  using FetchInfo12 = InvocationToFetch<ThreadIndicesType, Invocation, 12>;
5032  using FetchType12 = typename FetchInfo12::type;
5033  FetchType12 fetch12;
5034  auto p12 =
5035  fetch12.Load(threadIndices, FetchInfo12::GetParameter(invocation));
5036 
5037  using FetchInfo13 = InvocationToFetch<ThreadIndicesType, Invocation, 13>;
5038  using FetchType13 = typename FetchInfo13::type;
5039  FetchType13 fetch13;
5040  auto p13 =
5041  fetch13.Load(threadIndices, FetchInfo13::GetParameter(invocation));
5042 
5043  using FetchInfo14 = InvocationToFetch<ThreadIndicesType, Invocation, 14>;
5044  using FetchType14 = typename FetchInfo14::type;
5045  FetchType14 fetch14;
5046  auto p14 =
5047  fetch14.Load(threadIndices, FetchInfo14::GetParameter(invocation));
5048 
5049  using FetchInfo15 = InvocationToFetch<ThreadIndicesType, Invocation, 15>;
5050  using FetchType15 = typename FetchInfo15::type;
5051  FetchType15 fetch15;
5052  auto p15 =
5053  fetch15.Load(threadIndices, FetchInfo15::GetParameter(invocation));
5054 
5055  using FetchInfo16 = InvocationToFetch<ThreadIndicesType, Invocation, 16>;
5056  using FetchType16 = typename FetchInfo16::type;
5057  FetchType16 fetch16;
5058  auto p16 =
5059  fetch16.Load(threadIndices, FetchInfo16::GetParameter(invocation));
5060 
5061  using FetchInfo17 = InvocationToFetch<ThreadIndicesType, Invocation, 17>;
5062  using FetchType17 = typename FetchInfo17::type;
5063  FetchType17 fetch17;
5064  auto p17 =
5065  fetch17.Load(threadIndices, FetchInfo17::GetParameter(invocation));
5066 
5067  using FetchInfo18 = InvocationToFetch<ThreadIndicesType, Invocation, 18>;
5068  using FetchType18 = typename FetchInfo18::type;
5069  FetchType18 fetch18;
5070  auto p18 =
5071  fetch18.Load(threadIndices, FetchInfo18::GetParameter(invocation));
5072 
5073  using FetchInfo19 = InvocationToFetch<ThreadIndicesType, Invocation, 19>;
5074  using FetchType19 = typename FetchInfo19::type;
5075  FetchType19 fetch19;
5076  auto p19 =
5077  fetch19.Load(threadIndices, FetchInfo19::GetParameter(invocation));
5078 
5079  using FetchInfo20 = InvocationToFetch<ThreadIndicesType, Invocation, 20>;
5080  using FetchType20 = typename FetchInfo20::type;
5081  FetchType20 fetch20;
5082  auto p20 =
5083  fetch20.Load(threadIndices, FetchInfo20::GetParameter(invocation));
5084 
5085  using FetchInfo0 = InvocationToFetch<ThreadIndicesType, Invocation, 0>;
5086  using ReturnFetchType = typename FetchInfo0::type;
5087  ReturnFetchType returnFetch;
5088  // If you got a compile error on the following line, it probably means that
5089  // the operator() of a worklet does not match the definition expected. One
5090  // common problem is that the operator() method must be declared const. Check
5091  // to make sure the "const" keyword is after parameters. Another common
5092  // problem is that the type of one or more parameters is incompatible with
5093  // the actual type that VTK-m creates in the execution environment. Make sure
5094  // that the types of the worklet operator() parameters match those in the
5095  // ExecutionSignature. The compiler error might help you narrow down which
5096  // parameter is wrong and the types that did not match.
5097  auto r = worklet(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20);
5098 
5099  fetch1.Store(threadIndices, FetchInfo1::GetParameter(invocation), p1);
5100  fetch2.Store(threadIndices, FetchInfo2::GetParameter(invocation), p2);
5101  fetch3.Store(threadIndices, FetchInfo3::GetParameter(invocation), p3);
5102  fetch4.Store(threadIndices, FetchInfo4::GetParameter(invocation), p4);
5103  fetch5.Store(threadIndices, FetchInfo5::GetParameter(invocation), p5);
5104  fetch6.Store(threadIndices, FetchInfo6::GetParameter(invocation), p6);
5105  fetch7.Store(threadIndices, FetchInfo7::GetParameter(invocation), p7);
5106  fetch8.Store(threadIndices, FetchInfo8::GetParameter(invocation), p8);
5107  fetch9.Store(threadIndices, FetchInfo9::GetParameter(invocation), p9);
5108  fetch10.Store(threadIndices, FetchInfo10::GetParameter(invocation), p10);
5109  fetch11.Store(threadIndices, FetchInfo11::GetParameter(invocation), p11);
5110  fetch12.Store(threadIndices, FetchInfo12::GetParameter(invocation), p12);
5111  fetch13.Store(threadIndices, FetchInfo13::GetParameter(invocation), p13);
5112  fetch14.Store(threadIndices, FetchInfo14::GetParameter(invocation), p14);
5113  fetch15.Store(threadIndices, FetchInfo15::GetParameter(invocation), p15);
5114  fetch16.Store(threadIndices, FetchInfo16::GetParameter(invocation), p16);
5115  fetch17.Store(threadIndices, FetchInfo17::GetParameter(invocation), p17);
5116  fetch18.Store(threadIndices, FetchInfo18::GetParameter(invocation), p18);
5117  fetch19.Store(threadIndices, FetchInfo19::GetParameter(invocation), p19);
5118  fetch20.Store(threadIndices, FetchInfo20::GetParameter(invocation), p20);
5119 
5120  returnFetch.Store(threadIndices, FetchInfo0::GetParameter(invocation), r);
5121 }
5122 
5123 template <typename WorkletType,
5124  typename ParameterInterface,
5125  typename ControlInterface,
5126  vtkm::IdComponent InputDomainIndex,
5127  typename OutputToInputMapType,
5128  typename VisitArrayType,
5129  typename ThreadToOutputMapType,
5130  typename DeviceAdapterTag,
5131  typename ThreadIndicesType,
5132  typename P1,
5133  typename P2,
5134  typename P3,
5135  typename P4,
5136  typename P5,
5137  typename P6,
5138  typename P7,
5139  typename P8,
5140  typename P9,
5141  typename P10,
5142  typename P11,
5143  typename P12,
5144  typename P13,
5145  typename P14,
5146  typename P15,
5147  typename P16,
5148  typename P17,
5149  typename P18,
5150  typename P19,
5151  typename P20>
5152 VTKM_EXEC void DoWorkletInvokeFunctor(
5153  const WorkletType& worklet,
5154  const vtkm::internal::Invocation<ParameterInterface,
5155  ControlInterface,
5156  vtkm::internal::FunctionInterface<void(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20)>,
5157  InputDomainIndex,
5158  OutputToInputMapType,
5159  VisitArrayType,
5160  ThreadToOutputMapType,
5161  DeviceAdapterTag>& invocation,
5162  const ThreadIndicesType& threadIndices)
5163 {
5164  using Invocation =
5165  vtkm::internal::Invocation<ParameterInterface,
5166  ControlInterface,
5167  vtkm::internal::FunctionInterface<void(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20)>,
5168  InputDomainIndex,
5169  OutputToInputMapType,
5170  VisitArrayType,
5171  ThreadToOutputMapType,
5172  DeviceAdapterTag>;
5173 
5174  using FetchInfo1 = InvocationToFetch<ThreadIndicesType, Invocation, 1>;
5175  using FetchType1 = typename FetchInfo1::type;
5176  FetchType1 fetch1;
5177  auto p1 =
5178  fetch1.Load(threadIndices, FetchInfo1::GetParameter(invocation));
5179 
5180  using FetchInfo2 = InvocationToFetch<ThreadIndicesType, Invocation, 2>;
5181  using FetchType2 = typename FetchInfo2::type;
5182  FetchType2 fetch2;
5183  auto p2 =
5184  fetch2.Load(threadIndices, FetchInfo2::GetParameter(invocation));
5185 
5186  using FetchInfo3 = InvocationToFetch<ThreadIndicesType, Invocation, 3>;
5187  using FetchType3 = typename FetchInfo3::type;
5188  FetchType3 fetch3;
5189  auto p3 =
5190  fetch3.Load(threadIndices, FetchInfo3::GetParameter(invocation));
5191 
5192  using FetchInfo4 = InvocationToFetch<ThreadIndicesType, Invocation, 4>;
5193  using FetchType4 = typename FetchInfo4::type;
5194  FetchType4 fetch4;
5195  auto p4 =
5196  fetch4.Load(threadIndices, FetchInfo4::GetParameter(invocation));
5197 
5198  using FetchInfo5 = InvocationToFetch<ThreadIndicesType, Invocation, 5>;
5199  using FetchType5 = typename FetchInfo5::type;
5200  FetchType5 fetch5;
5201  auto p5 =
5202  fetch5.Load(threadIndices, FetchInfo5::GetParameter(invocation));
5203 
5204  using FetchInfo6 = InvocationToFetch<ThreadIndicesType, Invocation, 6>;
5205  using FetchType6 = typename FetchInfo6::type;
5206  FetchType6 fetch6;
5207  auto p6 =
5208  fetch6.Load(threadIndices, FetchInfo6::GetParameter(invocation));
5209 
5210  using FetchInfo7 = InvocationToFetch<ThreadIndicesType, Invocation, 7>;
5211  using FetchType7 = typename FetchInfo7::type;
5212  FetchType7 fetch7;
5213  auto p7 =
5214  fetch7.Load(threadIndices, FetchInfo7::GetParameter(invocation));
5215 
5216  using FetchInfo8 = InvocationToFetch<ThreadIndicesType, Invocation, 8>;
5217  using FetchType8 = typename FetchInfo8::type;
5218  FetchType8 fetch8;
5219  auto p8 =
5220  fetch8.Load(threadIndices, FetchInfo8::GetParameter(invocation));
5221 
5222  using FetchInfo9 = InvocationToFetch<ThreadIndicesType, Invocation, 9>;
5223  using FetchType9 = typename FetchInfo9::type;
5224  FetchType9 fetch9;
5225  auto p9 =
5226  fetch9.Load(threadIndices, FetchInfo9::GetParameter(invocation));
5227 
5228  using FetchInfo10 = InvocationToFetch<ThreadIndicesType, Invocation, 10>;
5229  using FetchType10 = typename FetchInfo10::type;
5230  FetchType10 fetch10;
5231  auto p10 =
5232  fetch10.Load(threadIndices, FetchInfo10::GetParameter(invocation));
5233 
5234  using FetchInfo11 = InvocationToFetch<ThreadIndicesType, Invocation, 11>;
5235  using FetchType11 = typename FetchInfo11::type;
5236  FetchType11 fetch11;
5237  auto p11 =
5238  fetch11.Load(threadIndices, FetchInfo11::GetParameter(invocation));
5239 
5240  using FetchInfo12 = InvocationToFetch<ThreadIndicesType, Invocation, 12>;
5241  using FetchType12 = typename FetchInfo12::type;
5242  FetchType12 fetch12;
5243  auto p12 =
5244  fetch12.Load(threadIndices, FetchInfo12::GetParameter(invocation));
5245 
5246  using FetchInfo13 = InvocationToFetch<ThreadIndicesType, Invocation, 13>;
5247  using FetchType13 = typename FetchInfo13::type;
5248  FetchType13 fetch13;
5249  auto p13 =
5250  fetch13.Load(threadIndices, FetchInfo13::GetParameter(invocation));
5251 
5252  using FetchInfo14 = InvocationToFetch<ThreadIndicesType, Invocation, 14>;
5253  using FetchType14 = typename FetchInfo14::type;
5254  FetchType14 fetch14;
5255  auto p14 =
5256  fetch14.Load(threadIndices, FetchInfo14::GetParameter(invocation));
5257 
5258  using FetchInfo15 = InvocationToFetch<ThreadIndicesType, Invocation, 15>;
5259  using FetchType15 = typename FetchInfo15::type;
5260  FetchType15 fetch15;
5261  auto p15 =
5262  fetch15.Load(threadIndices, FetchInfo15::GetParameter(invocation));
5263 
5264  using FetchInfo16 = InvocationToFetch<ThreadIndicesType, Invocation, 16>;
5265  using FetchType16 = typename FetchInfo16::type;
5266  FetchType16 fetch16;
5267  auto p16 =
5268  fetch16.Load(threadIndices, FetchInfo16::GetParameter(invocation));
5269 
5270  using FetchInfo17 = InvocationToFetch<ThreadIndicesType, Invocation, 17>;
5271  using FetchType17 = typename FetchInfo17::type;
5272  FetchType17 fetch17;
5273  auto p17 =
5274  fetch17.Load(threadIndices, FetchInfo17::GetParameter(invocation));
5275 
5276  using FetchInfo18 = InvocationToFetch<ThreadIndicesType, Invocation, 18>;
5277  using FetchType18 = typename FetchInfo18::type;
5278  FetchType18 fetch18;
5279  auto p18 =
5280  fetch18.Load(threadIndices, FetchInfo18::GetParameter(invocation));
5281 
5282  using FetchInfo19 = InvocationToFetch<ThreadIndicesType, Invocation, 19>;
5283  using FetchType19 = typename FetchInfo19::type;
5284  FetchType19 fetch19;
5285  auto p19 =
5286  fetch19.Load(threadIndices, FetchInfo19::GetParameter(invocation));
5287 
5288  using FetchInfo20 = InvocationToFetch<ThreadIndicesType, Invocation, 20>;
5289  using FetchType20 = typename FetchInfo20::type;
5290  FetchType20 fetch20;
5291  auto p20 =
5292  fetch20.Load(threadIndices, FetchInfo20::GetParameter(invocation));
5293 
5294  // If you got a compile error on the following line, it probably means that
5295  // the operator() of a worklet does not match the definition expected. One
5296  // common problem is that the operator() method must be declared const. Check
5297  // to make sure the "const" keyword is after parameters. Another common
5298  // problem is that the type of one or more parameters is incompatible with
5299  // the actual type that VTK-m creates in the execution environment. Make sure
5300  // that the types of the worklet operator() parameters match those in the
5301  // ExecutionSignature. The compiler error might help you narrow down which
5302  // parameter is wrong and the types that did not match.
5303  worklet(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17, p18, p19, p20);
5304 
5305  fetch1.Store(threadIndices, FetchInfo1::GetParameter(invocation), p1);
5306  fetch2.Store(threadIndices, FetchInfo2::GetParameter(invocation), p2);
5307  fetch3.Store(threadIndices, FetchInfo3::GetParameter(invocation), p3);
5308  fetch4.Store(threadIndices, FetchInfo4::GetParameter(invocation), p4);
5309  fetch5.Store(threadIndices, FetchInfo5::GetParameter(invocation), p5);
5310  fetch6.Store(threadIndices, FetchInfo6::GetParameter(invocation), p6);
5311  fetch7.Store(threadIndices, FetchInfo7::GetParameter(invocation), p7);
5312  fetch8.Store(threadIndices, FetchInfo8::GetParameter(invocation), p8);
5313  fetch9.Store(threadIndices, FetchInfo9::GetParameter(invocation), p9);
5314  fetch10.Store(threadIndices, FetchInfo10::GetParameter(invocation), p10);
5315  fetch11.Store(threadIndices, FetchInfo11::GetParameter(invocation), p11);
5316  fetch12.Store(threadIndices, FetchInfo12::GetParameter(invocation), p12);
5317  fetch13.Store(threadIndices, FetchInfo13::GetParameter(invocation), p13);
5318  fetch14.Store(threadIndices, FetchInfo14::GetParameter(invocation), p14);
5319  fetch15.Store(threadIndices, FetchInfo15::GetParameter(invocation), p15);
5320  fetch16.Store(threadIndices, FetchInfo16::GetParameter(invocation), p16);
5321  fetch17.Store(threadIndices, FetchInfo17::GetParameter(invocation), p17);
5322  fetch18.Store(threadIndices, FetchInfo18::GetParameter(invocation), p18);
5323  fetch19.Store(threadIndices, FetchInfo19::GetParameter(invocation), p19);
5324  fetch20.Store(threadIndices, FetchInfo20::GetParameter(invocation), p20);
5325 }
5326 
5327 // clang-format on
5328 }
5329 }
5330 }
5331 } // namespace vtkm::exec::internal::detail
5332 
5333 #endif //vtk_m_exec_internal_WorkletInvokeFunctorDetail_h
vtkm::exec::arg::FetchTagExecObject
Fetch tag for execution objects.
Definition: FetchTagExecObject.h:32
VTKM_EXEC
#define VTKM_EXEC
Definition: ExportMacros.h:51
vtkm
Groups connected points that have the same field value.
Definition: Atomic.h:19
vtkm::IdComponent
vtkm::Int32 IdComponent
Base type to use to index small lists.
Definition: Types.h:194
vtkm::exec::arg::Fetch
Class for loading and storing values in thread instance.
Definition: Fetch.h:49
FetchTagExecObject.h
Fetch.h
FunctionInterface.h
Invocation.h
Generated by   doxygen 1.8.17