Shuenhoy/vtk-m2
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
9816c422b1
vtk-m2/vtkm/internal/VariantImplDetail.h

2980 lines
132 KiB
C
Raw Normal View History

Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
//============================================================================
// Copyright (c) Kitware, Inc.
// All rights reserved.
// See LICENSE.txt for details.
//
// This software is distributed WITHOUT ANY WARRANTY; without even
// the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
// PURPOSE. See the above copyright notice for more information.
//============================================================================
// **** DO NOT EDIT THIS FILE!!! ****
// This file is automatically generated by VariantDetail.h.in
Make separate exec and cont versions of Variant The `Variant` class is templated to hold objects of other types. Depending on whether those objects of are meant to be used in the control or execution side, the methods on `Variant` might need to be declared with (or without) special modifiers. We can sometimes try to compile the `Variant` methods for both host and device and ask the device compiler to ignore incompatibilities, but that does not always work. To get around that, create two different implementations of `Variant`. Their API and implementation is exactly the same except one declares its methods with `VTKM_CONT` and the other its methods `VTKM_EXEC`.
2020-10-06 21:57:04 +00:00
#if !defined(VTK_M_DEVICE) || !defined(VTK_M_NAMESPACE)
#error VarianImplDetail.h must be included from VariantImpl.h
Do not attempt to move non-trivial objects in Variant The `Variant` class has separate implementations for its move and copy constructors/assignment operators depending on whether the classes it holds can be trivially moved. If the objects are trivial, Variant is trivial as well. However, in the case where the objects are not trivial, special construction and copying needs to be done. Previously, the non-trivial `Variant` defined a move constructor that did a byte copy of the contained object and reset the right hand side object so that it did not attempt to destroy the object. That usually works because it guarantees that only one version of the `Variant` will attempt to destroy the object and its resources should be cleaned up correctly. But C++ is a funny language that lets you do weird things. Turns out there are cases where moving the location of memory for an object without calling the proper copy method can invalidate the object. For example, if the object holds a pointer to one of its own members, that pointer will become invalid. Also, if it points to something that points back, then the object will need to update those pointers when it is moved. GCC's version of `std::string` seems to be a type like this. Solve the problem by simply deleting the move constructors. The copy constructors and destructor will be called instead to properly manage the object. A test for these conditions is added to `UnitTestVariant`.
2020-10-08 18:02:27 +00:00
// Some defines to make my IDE happy.
#define VTK_M_DEVICE
#define VTK_M_NAMESPACE tmp
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
#endif
#include <vtkm/Types.h>
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
#include <vtkm/internal/Assume.h>
#include <vtkmstd/is_trivial.h>
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
#include <type_traits>
namespace vtkm
{
Make separate exec and cont versions of Variant The `Variant` class is templated to hold objects of other types. Depending on whether those objects of are meant to be used in the control or execution side, the methods on `Variant` might need to be declared with (or without) special modifiers. We can sometimes try to compile the `Variant` methods for both host and device and ask the device compiler to ignore incompatibilities, but that does not always work. To get around that, create two different implementations of `Variant`. Their API and implementation is exactly the same except one declares its methods with `VTKM_CONT` and the other its methods `VTKM_EXEC`.
2020-10-06 21:57:04 +00:00
namespace VTK_M_NAMESPACE
{
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
namespace internal
{
namespace detail
{
template <typename ReturnType>
struct VariantDummyReturn
{
Make separate exec and cont versions of Variant The `Variant` class is templated to hold objects of other types. Depending on whether those objects of are meant to be used in the control or execution side, the methods on `Variant` might need to be declared with (or without) special modifiers. We can sometimes try to compile the `Variant` methods for both host and device and ask the device compiler to ignore incompatibilities, but that does not always work. To get around that, create two different implementations of `Variant`. Their API and implementation is exactly the same except one declares its methods with `VTKM_CONT` and the other its methods `VTKM_EXEC`.
2020-10-06 21:57:04 +00:00
VTK_M_DEVICE static inline ReturnType F() noexcept { return ReturnType{}; }
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
};
template <>
struct VariantDummyReturn<void>
{
Make separate exec and cont versions of Variant The `Variant` class is templated to hold objects of other types. Depending on whether those objects of are meant to be used in the control or execution side, the methods on `Variant` might need to be declared with (or without) special modifiers. We can sometimes try to compile the `Variant` methods for both host and device and ask the device compiler to ignore incompatibilities, but that does not always work. To get around that, create two different implementations of `Variant`. Their API and implementation is exactly the same except one declares its methods with `VTKM_CONT` and the other its methods `VTKM_EXEC`.
2020-10-06 21:57:04 +00:00
VTK_M_DEVICE static inline void F() noexcept {}
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
};
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
// clang-format off
// --------------------------------------------------------------------------------
// Helper classes to determine if all Variant types are trivial.
template <typename... Ts>
struct AllTriviallyCopyable;
template <typename T0>
struct AllTriviallyCopyable<T0>
: std::integral_constant<bool, (vtkmstd::is_trivially_copyable<T0>::value &&
true)> { };
template <typename T0, typename T1>
struct AllTriviallyCopyable<T0, T1>
: std::integral_constant<bool, (vtkmstd::is_trivially_copyable<T0>::value &&
vtkmstd::is_trivially_copyable<T1>::value &&
true)> { };
template <typename T0, typename T1, typename T2>
struct AllTriviallyCopyable<T0, T1, T2>
: std::integral_constant<bool, (vtkmstd::is_trivially_copyable<T0>::value &&
vtkmstd::is_trivially_copyable<T1>::value &&
vtkmstd::is_trivially_copyable<T2>::value &&
true)> { };
template <typename T0, typename T1, typename T2, typename T3>
struct AllTriviallyCopyable<T0, T1, T2, T3>
: std::integral_constant<bool, (vtkmstd::is_trivially_copyable<T0>::value &&
vtkmstd::is_trivially_copyable<T1>::value &&
vtkmstd::is_trivially_copyable<T2>::value &&
vtkmstd::is_trivially_copyable<T3>::value &&
true)> { };
template <typename T0, typename T1, typename T2, typename T3, typename T4>
struct AllTriviallyCopyable<T0, T1, T2, T3, T4>
: std::integral_constant<bool, (vtkmstd::is_trivially_copyable<T0>::value &&
vtkmstd::is_trivially_copyable<T1>::value &&
vtkmstd::is_trivially_copyable<T2>::value &&
vtkmstd::is_trivially_copyable<T3>::value &&
vtkmstd::is_trivially_copyable<T4>::value &&
true)> { };
template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5>
struct AllTriviallyCopyable<T0, T1, T2, T3, T4, T5>
: std::integral_constant<bool, (vtkmstd::is_trivially_copyable<T0>::value &&
vtkmstd::is_trivially_copyable<T1>::value &&
vtkmstd::is_trivially_copyable<T2>::value &&
vtkmstd::is_trivially_copyable<T3>::value &&
vtkmstd::is_trivially_copyable<T4>::value &&
vtkmstd::is_trivially_copyable<T5>::value &&
true)> { };
template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
struct AllTriviallyCopyable<T0, T1, T2, T3, T4, T5, T6>
: std::integral_constant<bool, (vtkmstd::is_trivially_copyable<T0>::value &&
vtkmstd::is_trivially_copyable<T1>::value &&
vtkmstd::is_trivially_copyable<T2>::value &&
vtkmstd::is_trivially_copyable<T3>::value &&
vtkmstd::is_trivially_copyable<T4>::value &&
vtkmstd::is_trivially_copyable<T5>::value &&
vtkmstd::is_trivially_copyable<T6>::value &&
true)> { };
template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7>
struct AllTriviallyCopyable<T0, T1, T2, T3, T4, T5, T6, T7>
: std::integral_constant<bool, (vtkmstd::is_trivially_copyable<T0>::value &&
vtkmstd::is_trivially_copyable<T1>::value &&
vtkmstd::is_trivially_copyable<T2>::value &&
vtkmstd::is_trivially_copyable<T3>::value &&
vtkmstd::is_trivially_copyable<T4>::value &&
vtkmstd::is_trivially_copyable<T5>::value &&
vtkmstd::is_trivially_copyable<T6>::value &&
vtkmstd::is_trivially_copyable<T7>::value &&
true)> { };
template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8>
struct AllTriviallyCopyable<T0, T1, T2, T3, T4, T5, T6, T7, T8>
: std::integral_constant<bool, (vtkmstd::is_trivially_copyable<T0>::value &&
vtkmstd::is_trivially_copyable<T1>::value &&
vtkmstd::is_trivially_copyable<T2>::value &&
vtkmstd::is_trivially_copyable<T3>::value &&
vtkmstd::is_trivially_copyable<T4>::value &&
vtkmstd::is_trivially_copyable<T5>::value &&
vtkmstd::is_trivially_copyable<T6>::value &&
vtkmstd::is_trivially_copyable<T7>::value &&
vtkmstd::is_trivially_copyable<T8>::value &&
true)> { };
template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9>
struct AllTriviallyCopyable<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>
: std::integral_constant<bool, (vtkmstd::is_trivially_copyable<T0>::value &&
vtkmstd::is_trivially_copyable<T1>::value &&
vtkmstd::is_trivially_copyable<T2>::value &&
vtkmstd::is_trivially_copyable<T3>::value &&
vtkmstd::is_trivially_copyable<T4>::value &&
vtkmstd::is_trivially_copyable<T5>::value &&
vtkmstd::is_trivially_copyable<T6>::value &&
vtkmstd::is_trivially_copyable<T7>::value &&
vtkmstd::is_trivially_copyable<T8>::value &&
vtkmstd::is_trivially_copyable<T9>::value &&
true)> { };
template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10>
struct AllTriviallyCopyable<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>
: std::integral_constant<bool, (vtkmstd::is_trivially_copyable<T0>::value &&
vtkmstd::is_trivially_copyable<T1>::value &&
vtkmstd::is_trivially_copyable<T2>::value &&
vtkmstd::is_trivially_copyable<T3>::value &&
vtkmstd::is_trivially_copyable<T4>::value &&
vtkmstd::is_trivially_copyable<T5>::value &&
vtkmstd::is_trivially_copyable<T6>::value &&
vtkmstd::is_trivially_copyable<T7>::value &&
vtkmstd::is_trivially_copyable<T8>::value &&
vtkmstd::is_trivially_copyable<T9>::value &&
vtkmstd::is_trivially_copyable<T10>::value &&
true)> { };
template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11>
struct AllTriviallyCopyable<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>
: std::integral_constant<bool, (vtkmstd::is_trivially_copyable<T0>::value &&
vtkmstd::is_trivially_copyable<T1>::value &&
vtkmstd::is_trivially_copyable<T2>::value &&
vtkmstd::is_trivially_copyable<T3>::value &&
vtkmstd::is_trivially_copyable<T4>::value &&
vtkmstd::is_trivially_copyable<T5>::value &&
vtkmstd::is_trivially_copyable<T6>::value &&
vtkmstd::is_trivially_copyable<T7>::value &&
vtkmstd::is_trivially_copyable<T8>::value &&
vtkmstd::is_trivially_copyable<T9>::value &&
vtkmstd::is_trivially_copyable<T10>::value &&
vtkmstd::is_trivially_copyable<T11>::value &&
true)> { };
template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12>
struct AllTriviallyCopyable<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>
: std::integral_constant<bool, (vtkmstd::is_trivially_copyable<T0>::value &&
vtkmstd::is_trivially_copyable<T1>::value &&
vtkmstd::is_trivially_copyable<T2>::value &&
vtkmstd::is_trivially_copyable<T3>::value &&
vtkmstd::is_trivially_copyable<T4>::value &&
vtkmstd::is_trivially_copyable<T5>::value &&
vtkmstd::is_trivially_copyable<T6>::value &&
vtkmstd::is_trivially_copyable<T7>::value &&
vtkmstd::is_trivially_copyable<T8>::value &&
vtkmstd::is_trivially_copyable<T9>::value &&
vtkmstd::is_trivially_copyable<T10>::value &&
vtkmstd::is_trivially_copyable<T11>::value &&
vtkmstd::is_trivially_copyable<T12>::value &&
true)> { };
template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13>
struct AllTriviallyCopyable<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>
: std::integral_constant<bool, (vtkmstd::is_trivially_copyable<T0>::value &&
vtkmstd::is_trivially_copyable<T1>::value &&
vtkmstd::is_trivially_copyable<T2>::value &&
vtkmstd::is_trivially_copyable<T3>::value &&
vtkmstd::is_trivially_copyable<T4>::value &&
vtkmstd::is_trivially_copyable<T5>::value &&
vtkmstd::is_trivially_copyable<T6>::value &&
vtkmstd::is_trivially_copyable<T7>::value &&
vtkmstd::is_trivially_copyable<T8>::value &&
vtkmstd::is_trivially_copyable<T9>::value &&
vtkmstd::is_trivially_copyable<T10>::value &&
vtkmstd::is_trivially_copyable<T11>::value &&
vtkmstd::is_trivially_copyable<T12>::value &&
vtkmstd::is_trivially_copyable<T13>::value &&
true)> { };
template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14>
struct AllTriviallyCopyable<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>
: std::integral_constant<bool, (vtkmstd::is_trivially_copyable<T0>::value &&
vtkmstd::is_trivially_copyable<T1>::value &&
vtkmstd::is_trivially_copyable<T2>::value &&
vtkmstd::is_trivially_copyable<T3>::value &&
vtkmstd::is_trivially_copyable<T4>::value &&
vtkmstd::is_trivially_copyable<T5>::value &&
vtkmstd::is_trivially_copyable<T6>::value &&
vtkmstd::is_trivially_copyable<T7>::value &&
vtkmstd::is_trivially_copyable<T8>::value &&
vtkmstd::is_trivially_copyable<T9>::value &&
vtkmstd::is_trivially_copyable<T10>::value &&
vtkmstd::is_trivially_copyable<T11>::value &&
vtkmstd::is_trivially_copyable<T12>::value &&
vtkmstd::is_trivially_copyable<T13>::value &&
vtkmstd::is_trivially_copyable<T14>::value &&
true)> { };
template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15>
struct AllTriviallyCopyable<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>
: std::integral_constant<bool, (vtkmstd::is_trivially_copyable<T0>::value &&
vtkmstd::is_trivially_copyable<T1>::value &&
vtkmstd::is_trivially_copyable<T2>::value &&
vtkmstd::is_trivially_copyable<T3>::value &&
vtkmstd::is_trivially_copyable<T4>::value &&
vtkmstd::is_trivially_copyable<T5>::value &&
vtkmstd::is_trivially_copyable<T6>::value &&
vtkmstd::is_trivially_copyable<T7>::value &&
vtkmstd::is_trivially_copyable<T8>::value &&
vtkmstd::is_trivially_copyable<T9>::value &&
vtkmstd::is_trivially_copyable<T10>::value &&
vtkmstd::is_trivially_copyable<T11>::value &&
vtkmstd::is_trivially_copyable<T12>::value &&
vtkmstd::is_trivially_copyable<T13>::value &&
vtkmstd::is_trivially_copyable<T14>::value &&
vtkmstd::is_trivially_copyable<T15>::value &&
true)> { };
template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16>
struct AllTriviallyCopyable<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>
: std::integral_constant<bool, (vtkmstd::is_trivially_copyable<T0>::value &&
vtkmstd::is_trivially_copyable<T1>::value &&
vtkmstd::is_trivially_copyable<T2>::value &&
vtkmstd::is_trivially_copyable<T3>::value &&
vtkmstd::is_trivially_copyable<T4>::value &&
vtkmstd::is_trivially_copyable<T5>::value &&
vtkmstd::is_trivially_copyable<T6>::value &&
vtkmstd::is_trivially_copyable<T7>::value &&
vtkmstd::is_trivially_copyable<T8>::value &&
vtkmstd::is_trivially_copyable<T9>::value &&
vtkmstd::is_trivially_copyable<T10>::value &&
vtkmstd::is_trivially_copyable<T11>::value &&
vtkmstd::is_trivially_copyable<T12>::value &&
vtkmstd::is_trivially_copyable<T13>::value &&
vtkmstd::is_trivially_copyable<T14>::value &&
vtkmstd::is_trivially_copyable<T15>::value &&
vtkmstd::is_trivially_copyable<T16>::value &&
true)> { };
template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17>
struct AllTriviallyCopyable<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17>
: std::integral_constant<bool, (vtkmstd::is_trivially_copyable<T0>::value &&
vtkmstd::is_trivially_copyable<T1>::value &&
vtkmstd::is_trivially_copyable<T2>::value &&
vtkmstd::is_trivially_copyable<T3>::value &&
vtkmstd::is_trivially_copyable<T4>::value &&
vtkmstd::is_trivially_copyable<T5>::value &&
vtkmstd::is_trivially_copyable<T6>::value &&
vtkmstd::is_trivially_copyable<T7>::value &&
vtkmstd::is_trivially_copyable<T8>::value &&
vtkmstd::is_trivially_copyable<T9>::value &&
vtkmstd::is_trivially_copyable<T10>::value &&
vtkmstd::is_trivially_copyable<T11>::value &&
vtkmstd::is_trivially_copyable<T12>::value &&
vtkmstd::is_trivially_copyable<T13>::value &&
vtkmstd::is_trivially_copyable<T14>::value &&
vtkmstd::is_trivially_copyable<T15>::value &&
vtkmstd::is_trivially_copyable<T16>::value &&
vtkmstd::is_trivially_copyable<T17>::value &&
true)> { };
template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18>
struct AllTriviallyCopyable<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>
: std::integral_constant<bool, (vtkmstd::is_trivially_copyable<T0>::value &&
vtkmstd::is_trivially_copyable<T1>::value &&
vtkmstd::is_trivially_copyable<T2>::value &&
vtkmstd::is_trivially_copyable<T3>::value &&
vtkmstd::is_trivially_copyable<T4>::value &&
vtkmstd::is_trivially_copyable<T5>::value &&
vtkmstd::is_trivially_copyable<T6>::value &&
vtkmstd::is_trivially_copyable<T7>::value &&
vtkmstd::is_trivially_copyable<T8>::value &&
vtkmstd::is_trivially_copyable<T9>::value &&
vtkmstd::is_trivially_copyable<T10>::value &&
vtkmstd::is_trivially_copyable<T11>::value &&
vtkmstd::is_trivially_copyable<T12>::value &&
vtkmstd::is_trivially_copyable<T13>::value &&
vtkmstd::is_trivially_copyable<T14>::value &&
vtkmstd::is_trivially_copyable<T15>::value &&
vtkmstd::is_trivially_copyable<T16>::value &&
vtkmstd::is_trivially_copyable<T17>::value &&
vtkmstd::is_trivially_copyable<T18>::value &&
true)> { };
template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18, typename T19>
struct AllTriviallyCopyable<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19>
: std::integral_constant<bool, (vtkmstd::is_trivially_copyable<T0>::value &&
vtkmstd::is_trivially_copyable<T1>::value &&
vtkmstd::is_trivially_copyable<T2>::value &&
vtkmstd::is_trivially_copyable<T3>::value &&
vtkmstd::is_trivially_copyable<T4>::value &&
vtkmstd::is_trivially_copyable<T5>::value &&
vtkmstd::is_trivially_copyable<T6>::value &&
vtkmstd::is_trivially_copyable<T7>::value &&
vtkmstd::is_trivially_copyable<T8>::value &&
vtkmstd::is_trivially_copyable<T9>::value &&
vtkmstd::is_trivially_copyable<T10>::value &&
vtkmstd::is_trivially_copyable<T11>::value &&
vtkmstd::is_trivially_copyable<T12>::value &&
vtkmstd::is_trivially_copyable<T13>::value &&
vtkmstd::is_trivially_copyable<T14>::value &&
vtkmstd::is_trivially_copyable<T15>::value &&
vtkmstd::is_trivially_copyable<T16>::value &&
vtkmstd::is_trivially_copyable<T17>::value &&
vtkmstd::is_trivially_copyable<T18>::value &&
vtkmstd::is_trivially_copyable<T19>::value &&
true)> { };
template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18, typename T19, typename T20, typename... Ts>
struct AllTriviallyCopyable<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, Ts...>
: std::integral_constant<bool, (vtkmstd::is_trivially_copyable<T0>::value &&
vtkmstd::is_trivially_copyable<T1>::value &&
vtkmstd::is_trivially_copyable<T2>::value &&
vtkmstd::is_trivially_copyable<T3>::value &&
vtkmstd::is_trivially_copyable<T4>::value &&
vtkmstd::is_trivially_copyable<T5>::value &&
vtkmstd::is_trivially_copyable<T6>::value &&
vtkmstd::is_trivially_copyable<T7>::value &&
vtkmstd::is_trivially_copyable<T8>::value &&
vtkmstd::is_trivially_copyable<T9>::value &&
vtkmstd::is_trivially_copyable<T10>::value &&
vtkmstd::is_trivially_copyable<T11>::value &&
vtkmstd::is_trivially_copyable<T12>::value &&
vtkmstd::is_trivially_copyable<T13>::value &&
vtkmstd::is_trivially_copyable<T14>::value &&
vtkmstd::is_trivially_copyable<T15>::value &&
vtkmstd::is_trivially_copyable<T16>::value &&
vtkmstd::is_trivially_copyable<T17>::value &&
vtkmstd::is_trivially_copyable<T18>::value &&
vtkmstd::is_trivially_copyable<T19>::value &&
AllTriviallyCopyable<T20, Ts...>::value)> { };
template <typename... Ts>
struct AllTriviallyConstructible;
template <typename T0>
struct AllTriviallyConstructible<T0>
: std::integral_constant<bool, (vtkmstd::is_trivially_constructible<T0>::value &&
true)> { };
template <typename T0, typename T1>
struct AllTriviallyConstructible<T0, T1>
: std::integral_constant<bool, (vtkmstd::is_trivially_constructible<T0>::value &&
vtkmstd::is_trivially_constructible<T1>::value &&
true)> { };
template <typename T0, typename T1, typename T2>
struct AllTriviallyConstructible<T0, T1, T2>
: std::integral_constant<bool, (vtkmstd::is_trivially_constructible<T0>::value &&
vtkmstd::is_trivially_constructible<T1>::value &&
vtkmstd::is_trivially_constructible<T2>::value &&
true)> { };
template <typename T0, typename T1, typename T2, typename T3>
struct AllTriviallyConstructible<T0, T1, T2, T3>
: std::integral_constant<bool, (vtkmstd::is_trivially_constructible<T0>::value &&
vtkmstd::is_trivially_constructible<T1>::value &&
vtkmstd::is_trivially_constructible<T2>::value &&
vtkmstd::is_trivially_constructible<T3>::value &&
true)> { };
template <typename T0, typename T1, typename T2, typename T3, typename T4>
struct AllTriviallyConstructible<T0, T1, T2, T3, T4>
: std::integral_constant<bool, (vtkmstd::is_trivially_constructible<T0>::value &&
vtkmstd::is_trivially_constructible<T1>::value &&
vtkmstd::is_trivially_constructible<T2>::value &&
vtkmstd::is_trivially_constructible<T3>::value &&
vtkmstd::is_trivially_constructible<T4>::value &&
true)> { };
template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5>
struct AllTriviallyConstructible<T0, T1, T2, T3, T4, T5>
: std::integral_constant<bool, (vtkmstd::is_trivially_constructible<T0>::value &&
vtkmstd::is_trivially_constructible<T1>::value &&
vtkmstd::is_trivially_constructible<T2>::value &&
vtkmstd::is_trivially_constructible<T3>::value &&
vtkmstd::is_trivially_constructible<T4>::value &&
vtkmstd::is_trivially_constructible<T5>::value &&
true)> { };
template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
struct AllTriviallyConstructible<T0, T1, T2, T3, T4, T5, T6>
: std::integral_constant<bool, (vtkmstd::is_trivially_constructible<T0>::value &&
vtkmstd::is_trivially_constructible<T1>::value &&
vtkmstd::is_trivially_constructible<T2>::value &&
vtkmstd::is_trivially_constructible<T3>::value &&
vtkmstd::is_trivially_constructible<T4>::value &&
vtkmstd::is_trivially_constructible<T5>::value &&
vtkmstd::is_trivially_constructible<T6>::value &&
true)> { };
template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7>
struct AllTriviallyConstructible<T0, T1, T2, T3, T4, T5, T6, T7>
: std::integral_constant<bool, (vtkmstd::is_trivially_constructible<T0>::value &&
vtkmstd::is_trivially_constructible<T1>::value &&
vtkmstd::is_trivially_constructible<T2>::value &&
vtkmstd::is_trivially_constructible<T3>::value &&
vtkmstd::is_trivially_constructible<T4>::value &&
vtkmstd::is_trivially_constructible<T5>::value &&
vtkmstd::is_trivially_constructible<T6>::value &&
vtkmstd::is_trivially_constructible<T7>::value &&
true)> { };
template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8>
struct AllTriviallyConstructible<T0, T1, T2, T3, T4, T5, T6, T7, T8>
: std::integral_constant<bool, (vtkmstd::is_trivially_constructible<T0>::value &&
vtkmstd::is_trivially_constructible<T1>::value &&
vtkmstd::is_trivially_constructible<T2>::value &&
vtkmstd::is_trivially_constructible<T3>::value &&
vtkmstd::is_trivially_constructible<T4>::value &&
vtkmstd::is_trivially_constructible<T5>::value &&
vtkmstd::is_trivially_constructible<T6>::value &&
vtkmstd::is_trivially_constructible<T7>::value &&
vtkmstd::is_trivially_constructible<T8>::value &&
true)> { };
template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9>
struct AllTriviallyConstructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>
: std::integral_constant<bool, (vtkmstd::is_trivially_constructible<T0>::value &&
vtkmstd::is_trivially_constructible<T1>::value &&
vtkmstd::is_trivially_constructible<T2>::value &&
vtkmstd::is_trivially_constructible<T3>::value &&
vtkmstd::is_trivially_constructible<T4>::value &&
vtkmstd::is_trivially_constructible<T5>::value &&
vtkmstd::is_trivially_constructible<T6>::value &&
vtkmstd::is_trivially_constructible<T7>::value &&
vtkmstd::is_trivially_constructible<T8>::value &&
vtkmstd::is_trivially_constructible<T9>::value &&
true)> { };
template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10>
struct AllTriviallyConstructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>
: std::integral_constant<bool, (vtkmstd::is_trivially_constructible<T0>::value &&
vtkmstd::is_trivially_constructible<T1>::value &&
vtkmstd::is_trivially_constructible<T2>::value &&
vtkmstd::is_trivially_constructible<T3>::value &&
vtkmstd::is_trivially_constructible<T4>::value &&
vtkmstd::is_trivially_constructible<T5>::value &&
vtkmstd::is_trivially_constructible<T6>::value &&
vtkmstd::is_trivially_constructible<T7>::value &&
vtkmstd::is_trivially_constructible<T8>::value &&
vtkmstd::is_trivially_constructible<T9>::value &&
vtkmstd::is_trivially_constructible<T10>::value &&
true)> { };
template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11>
struct AllTriviallyConstructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>
: std::integral_constant<bool, (vtkmstd::is_trivially_constructible<T0>::value &&
vtkmstd::is_trivially_constructible<T1>::value &&
vtkmstd::is_trivially_constructible<T2>::value &&
vtkmstd::is_trivially_constructible<T3>::value &&
vtkmstd::is_trivially_constructible<T4>::value &&
vtkmstd::is_trivially_constructible<T5>::value &&
vtkmstd::is_trivially_constructible<T6>::value &&
vtkmstd::is_trivially_constructible<T7>::value &&
vtkmstd::is_trivially_constructible<T8>::value &&
vtkmstd::is_trivially_constructible<T9>::value &&
vtkmstd::is_trivially_constructible<T10>::value &&
vtkmstd::is_trivially_constructible<T11>::value &&
true)> { };
template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12>
struct AllTriviallyConstructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>
: std::integral_constant<bool, (vtkmstd::is_trivially_constructible<T0>::value &&
vtkmstd::is_trivially_constructible<T1>::value &&
vtkmstd::is_trivially_constructible<T2>::value &&
vtkmstd::is_trivially_constructible<T3>::value &&
vtkmstd::is_trivially_constructible<T4>::value &&
vtkmstd::is_trivially_constructible<T5>::value &&
vtkmstd::is_trivially_constructible<T6>::value &&
vtkmstd::is_trivially_constructible<T7>::value &&
vtkmstd::is_trivially_constructible<T8>::value &&
vtkmstd::is_trivially_constructible<T9>::value &&
vtkmstd::is_trivially_constructible<T10>::value &&
vtkmstd::is_trivially_constructible<T11>::value &&
vtkmstd::is_trivially_constructible<T12>::value &&
true)> { };
template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13>
struct AllTriviallyConstructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>
: std::integral_constant<bool, (vtkmstd::is_trivially_constructible<T0>::value &&
vtkmstd::is_trivially_constructible<T1>::value &&
vtkmstd::is_trivially_constructible<T2>::value &&
vtkmstd::is_trivially_constructible<T3>::value &&
vtkmstd::is_trivially_constructible<T4>::value &&
vtkmstd::is_trivially_constructible<T5>::value &&
vtkmstd::is_trivially_constructible<T6>::value &&
vtkmstd::is_trivially_constructible<T7>::value &&
vtkmstd::is_trivially_constructible<T8>::value &&
vtkmstd::is_trivially_constructible<T9>::value &&
vtkmstd::is_trivially_constructible<T10>::value &&
vtkmstd::is_trivially_constructible<T11>::value &&
vtkmstd::is_trivially_constructible<T12>::value &&
vtkmstd::is_trivially_constructible<T13>::value &&
true)> { };
template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14>
struct AllTriviallyConstructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>
: std::integral_constant<bool, (vtkmstd::is_trivially_constructible<T0>::value &&
vtkmstd::is_trivially_constructible<T1>::value &&
vtkmstd::is_trivially_constructible<T2>::value &&
vtkmstd::is_trivially_constructible<T3>::value &&
vtkmstd::is_trivially_constructible<T4>::value &&
vtkmstd::is_trivially_constructible<T5>::value &&
vtkmstd::is_trivially_constructible<T6>::value &&
vtkmstd::is_trivially_constructible<T7>::value &&
vtkmstd::is_trivially_constructible<T8>::value &&
vtkmstd::is_trivially_constructible<T9>::value &&
vtkmstd::is_trivially_constructible<T10>::value &&
vtkmstd::is_trivially_constructible<T11>::value &&
vtkmstd::is_trivially_constructible<T12>::value &&
vtkmstd::is_trivially_constructible<T13>::value &&
vtkmstd::is_trivially_constructible<T14>::value &&
true)> { };
template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15>
struct AllTriviallyConstructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>
: std::integral_constant<bool, (vtkmstd::is_trivially_constructible<T0>::value &&
vtkmstd::is_trivially_constructible<T1>::value &&
vtkmstd::is_trivially_constructible<T2>::value &&
vtkmstd::is_trivially_constructible<T3>::value &&
vtkmstd::is_trivially_constructible<T4>::value &&
vtkmstd::is_trivially_constructible<T5>::value &&
vtkmstd::is_trivially_constructible<T6>::value &&
vtkmstd::is_trivially_constructible<T7>::value &&
vtkmstd::is_trivially_constructible<T8>::value &&
vtkmstd::is_trivially_constructible<T9>::value &&
vtkmstd::is_trivially_constructible<T10>::value &&
vtkmstd::is_trivially_constructible<T11>::value &&
vtkmstd::is_trivially_constructible<T12>::value &&
vtkmstd::is_trivially_constructible<T13>::value &&
vtkmstd::is_trivially_constructible<T14>::value &&
vtkmstd::is_trivially_constructible<T15>::value &&
true)> { };
template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16>
struct AllTriviallyConstructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>
: std::integral_constant<bool, (vtkmstd::is_trivially_constructible<T0>::value &&
vtkmstd::is_trivially_constructible<T1>::value &&
vtkmstd::is_trivially_constructible<T2>::value &&
vtkmstd::is_trivially_constructible<T3>::value &&
vtkmstd::is_trivially_constructible<T4>::value &&
vtkmstd::is_trivially_constructible<T5>::value &&
vtkmstd::is_trivially_constructible<T6>::value &&
vtkmstd::is_trivially_constructible<T7>::value &&
vtkmstd::is_trivially_constructible<T8>::value &&
vtkmstd::is_trivially_constructible<T9>::value &&
vtkmstd::is_trivially_constructible<T10>::value &&
vtkmstd::is_trivially_constructible<T11>::value &&
vtkmstd::is_trivially_constructible<T12>::value &&
vtkmstd::is_trivially_constructible<T13>::value &&
vtkmstd::is_trivially_constructible<T14>::value &&
vtkmstd::is_trivially_constructible<T15>::value &&
vtkmstd::is_trivially_constructible<T16>::value &&
true)> { };
template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17>
struct AllTriviallyConstructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17>
: std::integral_constant<bool, (vtkmstd::is_trivially_constructible<T0>::value &&
vtkmstd::is_trivially_constructible<T1>::value &&
vtkmstd::is_trivially_constructible<T2>::value &&
vtkmstd::is_trivially_constructible<T3>::value &&
vtkmstd::is_trivially_constructible<T4>::value &&
vtkmstd::is_trivially_constructible<T5>::value &&
vtkmstd::is_trivially_constructible<T6>::value &&
vtkmstd::is_trivially_constructible<T7>::value &&
vtkmstd::is_trivially_constructible<T8>::value &&
vtkmstd::is_trivially_constructible<T9>::value &&
vtkmstd::is_trivially_constructible<T10>::value &&
vtkmstd::is_trivially_constructible<T11>::value &&
vtkmstd::is_trivially_constructible<T12>::value &&
vtkmstd::is_trivially_constructible<T13>::value &&
vtkmstd::is_trivially_constructible<T14>::value &&
vtkmstd::is_trivially_constructible<T15>::value &&
vtkmstd::is_trivially_constructible<T16>::value &&
vtkmstd::is_trivially_constructible<T17>::value &&
true)> { };
template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18>
struct AllTriviallyConstructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>
: std::integral_constant<bool, (vtkmstd::is_trivially_constructible<T0>::value &&
vtkmstd::is_trivially_constructible<T1>::value &&
vtkmstd::is_trivially_constructible<T2>::value &&
vtkmstd::is_trivially_constructible<T3>::value &&
vtkmstd::is_trivially_constructible<T4>::value &&
vtkmstd::is_trivially_constructible<T5>::value &&
vtkmstd::is_trivially_constructible<T6>::value &&
vtkmstd::is_trivially_constructible<T7>::value &&
vtkmstd::is_trivially_constructible<T8>::value &&
vtkmstd::is_trivially_constructible<T9>::value &&
vtkmstd::is_trivially_constructible<T10>::value &&
vtkmstd::is_trivially_constructible<T11>::value &&
vtkmstd::is_trivially_constructible<T12>::value &&
vtkmstd::is_trivially_constructible<T13>::value &&
vtkmstd::is_trivially_constructible<T14>::value &&
vtkmstd::is_trivially_constructible<T15>::value &&
vtkmstd::is_trivially_constructible<T16>::value &&
vtkmstd::is_trivially_constructible<T17>::value &&
vtkmstd::is_trivially_constructible<T18>::value &&
true)> { };
template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18, typename T19>
struct AllTriviallyConstructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19>
: std::integral_constant<bool, (vtkmstd::is_trivially_constructible<T0>::value &&
vtkmstd::is_trivially_constructible<T1>::value &&
vtkmstd::is_trivially_constructible<T2>::value &&
vtkmstd::is_trivially_constructible<T3>::value &&
vtkmstd::is_trivially_constructible<T4>::value &&
vtkmstd::is_trivially_constructible<T5>::value &&
vtkmstd::is_trivially_constructible<T6>::value &&
vtkmstd::is_trivially_constructible<T7>::value &&
vtkmstd::is_trivially_constructible<T8>::value &&
vtkmstd::is_trivially_constructible<T9>::value &&
vtkmstd::is_trivially_constructible<T10>::value &&
vtkmstd::is_trivially_constructible<T11>::value &&
vtkmstd::is_trivially_constructible<T12>::value &&
vtkmstd::is_trivially_constructible<T13>::value &&
vtkmstd::is_trivially_constructible<T14>::value &&
vtkmstd::is_trivially_constructible<T15>::value &&
vtkmstd::is_trivially_constructible<T16>::value &&
vtkmstd::is_trivially_constructible<T17>::value &&
vtkmstd::is_trivially_constructible<T18>::value &&
vtkmstd::is_trivially_constructible<T19>::value &&
true)> { };
template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18, typename T19, typename T20, typename... Ts>
struct AllTriviallyConstructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, Ts...>
: std::integral_constant<bool, (vtkmstd::is_trivially_constructible<T0>::value &&
vtkmstd::is_trivially_constructible<T1>::value &&
vtkmstd::is_trivially_constructible<T2>::value &&
vtkmstd::is_trivially_constructible<T3>::value &&
vtkmstd::is_trivially_constructible<T4>::value &&
vtkmstd::is_trivially_constructible<T5>::value &&
vtkmstd::is_trivially_constructible<T6>::value &&
vtkmstd::is_trivially_constructible<T7>::value &&
vtkmstd::is_trivially_constructible<T8>::value &&
vtkmstd::is_trivially_constructible<T9>::value &&
vtkmstd::is_trivially_constructible<T10>::value &&
vtkmstd::is_trivially_constructible<T11>::value &&
vtkmstd::is_trivially_constructible<T12>::value &&
vtkmstd::is_trivially_constructible<T13>::value &&
vtkmstd::is_trivially_constructible<T14>::value &&
vtkmstd::is_trivially_constructible<T15>::value &&
vtkmstd::is_trivially_constructible<T16>::value &&
vtkmstd::is_trivially_constructible<T17>::value &&
vtkmstd::is_trivially_constructible<T18>::value &&
vtkmstd::is_trivially_constructible<T19>::value &&
AllTriviallyConstructible<T20, Ts...>::value)> { };
template <typename... Ts>
struct AllTriviallyDestructible;
template <typename T0>
struct AllTriviallyDestructible<T0>
: std::integral_constant<bool, (vtkmstd::is_trivially_destructible<T0>::value &&
true)> { };
template <typename T0, typename T1>
struct AllTriviallyDestructible<T0, T1>
: std::integral_constant<bool, (vtkmstd::is_trivially_destructible<T0>::value &&
vtkmstd::is_trivially_destructible<T1>::value &&
true)> { };
template <typename T0, typename T1, typename T2>
struct AllTriviallyDestructible<T0, T1, T2>
: std::integral_constant<bool, (vtkmstd::is_trivially_destructible<T0>::value &&
vtkmstd::is_trivially_destructible<T1>::value &&
vtkmstd::is_trivially_destructible<T2>::value &&
true)> { };
template <typename T0, typename T1, typename T2, typename T3>
struct AllTriviallyDestructible<T0, T1, T2, T3>
: std::integral_constant<bool, (vtkmstd::is_trivially_destructible<T0>::value &&
vtkmstd::is_trivially_destructible<T1>::value &&
vtkmstd::is_trivially_destructible<T2>::value &&
vtkmstd::is_trivially_destructible<T3>::value &&
true)> { };
template <typename T0, typename T1, typename T2, typename T3, typename T4>
struct AllTriviallyDestructible<T0, T1, T2, T3, T4>
: std::integral_constant<bool, (vtkmstd::is_trivially_destructible<T0>::value &&
vtkmstd::is_trivially_destructible<T1>::value &&
vtkmstd::is_trivially_destructible<T2>::value &&
vtkmstd::is_trivially_destructible<T3>::value &&
vtkmstd::is_trivially_destructible<T4>::value &&
true)> { };
template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5>
struct AllTriviallyDestructible<T0, T1, T2, T3, T4, T5>
: std::integral_constant<bool, (vtkmstd::is_trivially_destructible<T0>::value &&
vtkmstd::is_trivially_destructible<T1>::value &&
vtkmstd::is_trivially_destructible<T2>::value &&
vtkmstd::is_trivially_destructible<T3>::value &&
vtkmstd::is_trivially_destructible<T4>::value &&
vtkmstd::is_trivially_destructible<T5>::value &&
true)> { };
template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
struct AllTriviallyDestructible<T0, T1, T2, T3, T4, T5, T6>
: std::integral_constant<bool, (vtkmstd::is_trivially_destructible<T0>::value &&
vtkmstd::is_trivially_destructible<T1>::value &&
vtkmstd::is_trivially_destructible<T2>::value &&
vtkmstd::is_trivially_destructible<T3>::value &&
vtkmstd::is_trivially_destructible<T4>::value &&
vtkmstd::is_trivially_destructible<T5>::value &&
vtkmstd::is_trivially_destructible<T6>::value &&
true)> { };
template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7>
struct AllTriviallyDestructible<T0, T1, T2, T3, T4, T5, T6, T7>
: std::integral_constant<bool, (vtkmstd::is_trivially_destructible<T0>::value &&
vtkmstd::is_trivially_destructible<T1>::value &&
vtkmstd::is_trivially_destructible<T2>::value &&
vtkmstd::is_trivially_destructible<T3>::value &&
vtkmstd::is_trivially_destructible<T4>::value &&
vtkmstd::is_trivially_destructible<T5>::value &&
vtkmstd::is_trivially_destructible<T6>::value &&
vtkmstd::is_trivially_destructible<T7>::value &&
true)> { };
template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8>
struct AllTriviallyDestructible<T0, T1, T2, T3, T4, T5, T6, T7, T8>
: std::integral_constant<bool, (vtkmstd::is_trivially_destructible<T0>::value &&
vtkmstd::is_trivially_destructible<T1>::value &&
vtkmstd::is_trivially_destructible<T2>::value &&
vtkmstd::is_trivially_destructible<T3>::value &&
vtkmstd::is_trivially_destructible<T4>::value &&
vtkmstd::is_trivially_destructible<T5>::value &&
vtkmstd::is_trivially_destructible<T6>::value &&
vtkmstd::is_trivially_destructible<T7>::value &&
vtkmstd::is_trivially_destructible<T8>::value &&
true)> { };
template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9>
struct AllTriviallyDestructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>
: std::integral_constant<bool, (vtkmstd::is_trivially_destructible<T0>::value &&
vtkmstd::is_trivially_destructible<T1>::value &&
vtkmstd::is_trivially_destructible<T2>::value &&
vtkmstd::is_trivially_destructible<T3>::value &&
vtkmstd::is_trivially_destructible<T4>::value &&
vtkmstd::is_trivially_destructible<T5>::value &&
vtkmstd::is_trivially_destructible<T6>::value &&
vtkmstd::is_trivially_destructible<T7>::value &&
vtkmstd::is_trivially_destructible<T8>::value &&
vtkmstd::is_trivially_destructible<T9>::value &&
true)> { };
template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10>
struct AllTriviallyDestructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>
: std::integral_constant<bool, (vtkmstd::is_trivially_destructible<T0>::value &&
vtkmstd::is_trivially_destructible<T1>::value &&
vtkmstd::is_trivially_destructible<T2>::value &&
vtkmstd::is_trivially_destructible<T3>::value &&
vtkmstd::is_trivially_destructible<T4>::value &&
vtkmstd::is_trivially_destructible<T5>::value &&
vtkmstd::is_trivially_destructible<T6>::value &&
vtkmstd::is_trivially_destructible<T7>::value &&
vtkmstd::is_trivially_destructible<T8>::value &&
vtkmstd::is_trivially_destructible<T9>::value &&
vtkmstd::is_trivially_destructible<T10>::value &&
true)> { };
template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11>
struct AllTriviallyDestructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>
: std::integral_constant<bool, (vtkmstd::is_trivially_destructible<T0>::value &&
vtkmstd::is_trivially_destructible<T1>::value &&
vtkmstd::is_trivially_destructible<T2>::value &&
vtkmstd::is_trivially_destructible<T3>::value &&
vtkmstd::is_trivially_destructible<T4>::value &&
vtkmstd::is_trivially_destructible<T5>::value &&
vtkmstd::is_trivially_destructible<T6>::value &&
vtkmstd::is_trivially_destructible<T7>::value &&
vtkmstd::is_trivially_destructible<T8>::value &&
vtkmstd::is_trivially_destructible<T9>::value &&
vtkmstd::is_trivially_destructible<T10>::value &&
vtkmstd::is_trivially_destructible<T11>::value &&
true)> { };
template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12>
struct AllTriviallyDestructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>
: std::integral_constant<bool, (vtkmstd::is_trivially_destructible<T0>::value &&
vtkmstd::is_trivially_destructible<T1>::value &&
vtkmstd::is_trivially_destructible<T2>::value &&
vtkmstd::is_trivially_destructible<T3>::value &&
vtkmstd::is_trivially_destructible<T4>::value &&
vtkmstd::is_trivially_destructible<T5>::value &&
vtkmstd::is_trivially_destructible<T6>::value &&
vtkmstd::is_trivially_destructible<T7>::value &&
vtkmstd::is_trivially_destructible<T8>::value &&
vtkmstd::is_trivially_destructible<T9>::value &&
vtkmstd::is_trivially_destructible<T10>::value &&
vtkmstd::is_trivially_destructible<T11>::value &&
vtkmstd::is_trivially_destructible<T12>::value &&
true)> { };
template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13>
struct AllTriviallyDestructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>
: std::integral_constant<bool, (vtkmstd::is_trivially_destructible<T0>::value &&
vtkmstd::is_trivially_destructible<T1>::value &&
vtkmstd::is_trivially_destructible<T2>::value &&
vtkmstd::is_trivially_destructible<T3>::value &&
vtkmstd::is_trivially_destructible<T4>::value &&
vtkmstd::is_trivially_destructible<T5>::value &&
vtkmstd::is_trivially_destructible<T6>::value &&
vtkmstd::is_trivially_destructible<T7>::value &&
vtkmstd::is_trivially_destructible<T8>::value &&
vtkmstd::is_trivially_destructible<T9>::value &&
vtkmstd::is_trivially_destructible<T10>::value &&
vtkmstd::is_trivially_destructible<T11>::value &&
vtkmstd::is_trivially_destructible<T12>::value &&
vtkmstd::is_trivially_destructible<T13>::value &&
true)> { };
template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14>
struct AllTriviallyDestructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>
: std::integral_constant<bool, (vtkmstd::is_trivially_destructible<T0>::value &&
vtkmstd::is_trivially_destructible<T1>::value &&
vtkmstd::is_trivially_destructible<T2>::value &&
vtkmstd::is_trivially_destructible<T3>::value &&
vtkmstd::is_trivially_destructible<T4>::value &&
vtkmstd::is_trivially_destructible<T5>::value &&
vtkmstd::is_trivially_destructible<T6>::value &&
vtkmstd::is_trivially_destructible<T7>::value &&
vtkmstd::is_trivially_destructible<T8>::value &&
vtkmstd::is_trivially_destructible<T9>::value &&
vtkmstd::is_trivially_destructible<T10>::value &&
vtkmstd::is_trivially_destructible<T11>::value &&
vtkmstd::is_trivially_destructible<T12>::value &&
vtkmstd::is_trivially_destructible<T13>::value &&
vtkmstd::is_trivially_destructible<T14>::value &&
true)> { };
template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15>
struct AllTriviallyDestructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>
: std::integral_constant<bool, (vtkmstd::is_trivially_destructible<T0>::value &&
vtkmstd::is_trivially_destructible<T1>::value &&
vtkmstd::is_trivially_destructible<T2>::value &&
vtkmstd::is_trivially_destructible<T3>::value &&
vtkmstd::is_trivially_destructible<T4>::value &&
vtkmstd::is_trivially_destructible<T5>::value &&
vtkmstd::is_trivially_destructible<T6>::value &&
vtkmstd::is_trivially_destructible<T7>::value &&
vtkmstd::is_trivially_destructible<T8>::value &&
vtkmstd::is_trivially_destructible<T9>::value &&
vtkmstd::is_trivially_destructible<T10>::value &&
vtkmstd::is_trivially_destructible<T11>::value &&
vtkmstd::is_trivially_destructible<T12>::value &&
vtkmstd::is_trivially_destructible<T13>::value &&
vtkmstd::is_trivially_destructible<T14>::value &&
vtkmstd::is_trivially_destructible<T15>::value &&
true)> { };
template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16>
struct AllTriviallyDestructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>
: std::integral_constant<bool, (vtkmstd::is_trivially_destructible<T0>::value &&
vtkmstd::is_trivially_destructible<T1>::value &&
vtkmstd::is_trivially_destructible<T2>::value &&
vtkmstd::is_trivially_destructible<T3>::value &&
vtkmstd::is_trivially_destructible<T4>::value &&
vtkmstd::is_trivially_destructible<T5>::value &&
vtkmstd::is_trivially_destructible<T6>::value &&
vtkmstd::is_trivially_destructible<T7>::value &&
vtkmstd::is_trivially_destructible<T8>::value &&
vtkmstd::is_trivially_destructible<T9>::value &&
vtkmstd::is_trivially_destructible<T10>::value &&
vtkmstd::is_trivially_destructible<T11>::value &&
vtkmstd::is_trivially_destructible<T12>::value &&
vtkmstd::is_trivially_destructible<T13>::value &&
vtkmstd::is_trivially_destructible<T14>::value &&
vtkmstd::is_trivially_destructible<T15>::value &&
vtkmstd::is_trivially_destructible<T16>::value &&
true)> { };
template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17>
struct AllTriviallyDestructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17>
: std::integral_constant<bool, (vtkmstd::is_trivially_destructible<T0>::value &&
vtkmstd::is_trivially_destructible<T1>::value &&
vtkmstd::is_trivially_destructible<T2>::value &&
vtkmstd::is_trivially_destructible<T3>::value &&
vtkmstd::is_trivially_destructible<T4>::value &&
vtkmstd::is_trivially_destructible<T5>::value &&
vtkmstd::is_trivially_destructible<T6>::value &&
vtkmstd::is_trivially_destructible<T7>::value &&
vtkmstd::is_trivially_destructible<T8>::value &&
vtkmstd::is_trivially_destructible<T9>::value &&
vtkmstd::is_trivially_destructible<T10>::value &&
vtkmstd::is_trivially_destructible<T11>::value &&
vtkmstd::is_trivially_destructible<T12>::value &&
vtkmstd::is_trivially_destructible<T13>::value &&
vtkmstd::is_trivially_destructible<T14>::value &&
vtkmstd::is_trivially_destructible<T15>::value &&
vtkmstd::is_trivially_destructible<T16>::value &&
vtkmstd::is_trivially_destructible<T17>::value &&
true)> { };
template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18>
struct AllTriviallyDestructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>
: std::integral_constant<bool, (vtkmstd::is_trivially_destructible<T0>::value &&
vtkmstd::is_trivially_destructible<T1>::value &&
vtkmstd::is_trivially_destructible<T2>::value &&
vtkmstd::is_trivially_destructible<T3>::value &&
vtkmstd::is_trivially_destructible<T4>::value &&
vtkmstd::is_trivially_destructible<T5>::value &&
vtkmstd::is_trivially_destructible<T6>::value &&
vtkmstd::is_trivially_destructible<T7>::value &&
vtkmstd::is_trivially_destructible<T8>::value &&
vtkmstd::is_trivially_destructible<T9>::value &&
vtkmstd::is_trivially_destructible<T10>::value &&
vtkmstd::is_trivially_destructible<T11>::value &&
vtkmstd::is_trivially_destructible<T12>::value &&
vtkmstd::is_trivially_destructible<T13>::value &&
vtkmstd::is_trivially_destructible<T14>::value &&
vtkmstd::is_trivially_destructible<T15>::value &&
vtkmstd::is_trivially_destructible<T16>::value &&
vtkmstd::is_trivially_destructible<T17>::value &&
vtkmstd::is_trivially_destructible<T18>::value &&
true)> { };
template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18, typename T19>
struct AllTriviallyDestructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19>
: std::integral_constant<bool, (vtkmstd::is_trivially_destructible<T0>::value &&
vtkmstd::is_trivially_destructible<T1>::value &&
vtkmstd::is_trivially_destructible<T2>::value &&
vtkmstd::is_trivially_destructible<T3>::value &&
vtkmstd::is_trivially_destructible<T4>::value &&
vtkmstd::is_trivially_destructible<T5>::value &&
vtkmstd::is_trivially_destructible<T6>::value &&
vtkmstd::is_trivially_destructible<T7>::value &&
vtkmstd::is_trivially_destructible<T8>::value &&
vtkmstd::is_trivially_destructible<T9>::value &&
vtkmstd::is_trivially_destructible<T10>::value &&
vtkmstd::is_trivially_destructible<T11>::value &&
vtkmstd::is_trivially_destructible<T12>::value &&
vtkmstd::is_trivially_destructible<T13>::value &&
vtkmstd::is_trivially_destructible<T14>::value &&
vtkmstd::is_trivially_destructible<T15>::value &&
vtkmstd::is_trivially_destructible<T16>::value &&
vtkmstd::is_trivially_destructible<T17>::value &&
vtkmstd::is_trivially_destructible<T18>::value &&
vtkmstd::is_trivially_destructible<T19>::value &&
true)> { };
template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18, typename T19, typename T20, typename... Ts>
struct AllTriviallyDestructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, Ts...>
: std::integral_constant<bool, (vtkmstd::is_trivially_destructible<T0>::value &&
vtkmstd::is_trivially_destructible<T1>::value &&
vtkmstd::is_trivially_destructible<T2>::value &&
vtkmstd::is_trivially_destructible<T3>::value &&
vtkmstd::is_trivially_destructible<T4>::value &&
vtkmstd::is_trivially_destructible<T5>::value &&
vtkmstd::is_trivially_destructible<T6>::value &&
vtkmstd::is_trivially_destructible<T7>::value &&
vtkmstd::is_trivially_destructible<T8>::value &&
vtkmstd::is_trivially_destructible<T9>::value &&
vtkmstd::is_trivially_destructible<T10>::value &&
vtkmstd::is_trivially_destructible<T11>::value &&
vtkmstd::is_trivially_destructible<T12>::value &&
vtkmstd::is_trivially_destructible<T13>::value &&
vtkmstd::is_trivially_destructible<T14>::value &&
vtkmstd::is_trivially_destructible<T15>::value &&
vtkmstd::is_trivially_destructible<T16>::value &&
vtkmstd::is_trivially_destructible<T17>::value &&
vtkmstd::is_trivially_destructible<T18>::value &&
vtkmstd::is_trivially_destructible<T19>::value &&
AllTriviallyDestructible<T20, Ts...>::value)> { };
// --------------------------------------------------------------------------------
// Union type used inside of Variant
//
// You may be asking yourself, why not just use an std::aligned_union rather than a real union
// type? That was our first implementation, but the problem is that the std::aligned_union
// reference needs to be recast to the actual type. Typically you would do that with
// reinterpret_cast. However, doing that leads to undefined behavior. The C++ compiler assumes that
// 2 pointers of different types point to different memory (even if it is clear that they are set
// to the same address). That means optimizers can remove code because it "knows" that data in one
// type cannot affect data in another type. To safely change the type of an std::aligned_union,
// you really have to do an std::memcpy. This is problematic for types that cannot be trivially
// copied. Another problem is that we found that device compilers do not optimize the memcpy
// as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
//
// Part of the trickiness of the union implementation is trying to preserve when the type is
// trivially constructible and copyable. The trick is that if members of the union are not trivial,
// then the default constructors are deleted. To get around that, a non-default constructor is
// added, which we can use to construct the union for non-trivial types. Working with types with
// non-trivial destructors are particularly trick. Again, if any member of the union has a
// non-trivial destructor, the destructor is deleted. Unlike a constructor, you cannot just say to
// use a different destructor. Thus, we have to define our own destructor for the union.
// Technically, the destructor here does not do anything, but the actual destruction should be
// handled by the Variant class that contains this VariantUnion. We actually need two separate
// implementations of our union, one that defines a destructor and one that use the default
// destructor. If you define your own destructor, you can lose the trivial constructor and trivial
// copy properties.
//
// TD = trivially deconstructible
template <typename... Ts>
union VariantUnionTD;
// NTD = non-trivially deconstructible
template <typename... Ts>
union VariantUnionNTD;
template <typename T0>
union VariantUnionTD<T0>
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
{
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
T0 V0;
VTK_M_DEVICE VariantUnionTD(vtkm::internal::NullType) { }
VariantUnionTD() = default;
};
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
template <typename T0>
union VariantUnionNTD<T0>
{
T0 V0;
VTK_M_DEVICE VariantUnionNTD(vtkm::internal::NullType) { }
VariantUnionNTD() = default;
VTK_M_DEVICE ~VariantUnionNTD() { }
};
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
template <typename T0, typename T1>
union VariantUnionTD<T0, T1>
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
{
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
T0 V0;
T1 V1;
VTK_M_DEVICE VariantUnionTD(vtkm::internal::NullType) { }
VariantUnionTD() = default;
};
template <typename T0, typename T1>
union VariantUnionNTD<T0, T1>
{
T0 V0;
T1 V1;
VTK_M_DEVICE VariantUnionNTD(vtkm::internal::NullType) { }
VariantUnionNTD() = default;
VTK_M_DEVICE ~VariantUnionNTD() { }
};
template <typename T0, typename T1, typename T2>
union VariantUnionTD<T0, T1, T2>
{
T0 V0;
T1 V1;
T2 V2;
VTK_M_DEVICE VariantUnionTD(vtkm::internal::NullType) { }
VariantUnionTD() = default;
};
template <typename T0, typename T1, typename T2>
union VariantUnionNTD<T0, T1, T2>
{
T0 V0;
T1 V1;
T2 V2;
VTK_M_DEVICE VariantUnionNTD(vtkm::internal::NullType) { }
VariantUnionNTD() = default;
VTK_M_DEVICE ~VariantUnionNTD() { }
};
template <typename T0, typename T1, typename T2, typename T3>
union VariantUnionTD<T0, T1, T2, T3>
{
T0 V0;
T1 V1;
T2 V2;
T3 V3;
VTK_M_DEVICE VariantUnionTD(vtkm::internal::NullType) { }
VariantUnionTD() = default;
};
template <typename T0, typename T1, typename T2, typename T3>
union VariantUnionNTD<T0, T1, T2, T3>
{
T0 V0;
T1 V1;
T2 V2;
T3 V3;
VTK_M_DEVICE VariantUnionNTD(vtkm::internal::NullType) { }
VariantUnionNTD() = default;
VTK_M_DEVICE ~VariantUnionNTD() { }
};
template <typename T0, typename T1, typename T2, typename T3, typename T4>
union VariantUnionTD<T0, T1, T2, T3, T4>
{
T0 V0;
T1 V1;
T2 V2;
T3 V3;
T4 V4;
VTK_M_DEVICE VariantUnionTD(vtkm::internal::NullType) { }
VariantUnionTD() = default;
};
template <typename T0, typename T1, typename T2, typename T3, typename T4>
union VariantUnionNTD<T0, T1, T2, T3, T4>
{
T0 V0;
T1 V1;
T2 V2;
T3 V3;
T4 V4;
VTK_M_DEVICE VariantUnionNTD(vtkm::internal::NullType) { }
VariantUnionNTD() = default;
VTK_M_DEVICE ~VariantUnionNTD() { }
};
template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5>
union VariantUnionTD<T0, T1, T2, T3, T4, T5>
{
T0 V0;
T1 V1;
T2 V2;
T3 V3;
T4 V4;
T5 V5;
VTK_M_DEVICE VariantUnionTD(vtkm::internal::NullType) { }
VariantUnionTD() = default;
};
template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5>
union VariantUnionNTD<T0, T1, T2, T3, T4, T5>
{
T0 V0;
T1 V1;
T2 V2;
T3 V3;
T4 V4;
T5 V5;
VTK_M_DEVICE VariantUnionNTD(vtkm::internal::NullType) { }
VariantUnionNTD() = default;
VTK_M_DEVICE ~VariantUnionNTD() { }
};
template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
union VariantUnionTD<T0, T1, T2, T3, T4, T5, T6>
{
T0 V0;
T1 V1;
T2 V2;
T3 V3;
T4 V4;
T5 V5;
T6 V6;
VTK_M_DEVICE VariantUnionTD(vtkm::internal::NullType) { }
VariantUnionTD() = default;
};
template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
union VariantUnionNTD<T0, T1, T2, T3, T4, T5, T6>
{
T0 V0;
T1 V1;
T2 V2;
T3 V3;
T4 V4;
T5 V5;
T6 V6;
VTK_M_DEVICE VariantUnionNTD(vtkm::internal::NullType) { }
VariantUnionNTD() = default;
VTK_M_DEVICE ~VariantUnionNTD() { }
};
template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7>
union VariantUnionTD<T0, T1, T2, T3, T4, T5, T6, T7>
{
T0 V0;
T1 V1;
T2 V2;
T3 V3;
T4 V4;
T5 V5;
T6 V6;
T7 V7;
VTK_M_DEVICE VariantUnionTD(vtkm::internal::NullType) { }
VariantUnionTD() = default;
};
template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7>
union VariantUnionNTD<T0, T1, T2, T3, T4, T5, T6, T7>
{
T0 V0;
T1 V1;
T2 V2;
T3 V3;
T4 V4;
T5 V5;
T6 V6;
T7 V7;
VTK_M_DEVICE VariantUnionNTD(vtkm::internal::NullType) { }
VariantUnionNTD() = default;
VTK_M_DEVICE ~VariantUnionNTD() { }
};
template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8>
union VariantUnionTD<T0, T1, T2, T3, T4, T5, T6, T7, T8>
{
T0 V0;
T1 V1;
T2 V2;
T3 V3;
T4 V4;
T5 V5;
T6 V6;
T7 V7;
T8 V8;
VTK_M_DEVICE VariantUnionTD(vtkm::internal::NullType) { }
VariantUnionTD() = default;
};
template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8>
union VariantUnionNTD<T0, T1, T2, T3, T4, T5, T6, T7, T8>
{
T0 V0;
T1 V1;
T2 V2;
T3 V3;
T4 V4;
T5 V5;
T6 V6;
T7 V7;
T8 V8;
VTK_M_DEVICE VariantUnionNTD(vtkm::internal::NullType) { }
VariantUnionNTD() = default;
VTK_M_DEVICE ~VariantUnionNTD() { }
};
template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9>
union VariantUnionTD<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>
{
T0 V0;
T1 V1;
T2 V2;
T3 V3;
T4 V4;
T5 V5;
T6 V6;
T7 V7;
T8 V8;
T9 V9;
VTK_M_DEVICE VariantUnionTD(vtkm::internal::NullType) { }
VariantUnionTD() = default;
};
template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9>
union VariantUnionNTD<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>
{
T0 V0;
T1 V1;
T2 V2;
T3 V3;
T4 V4;
T5 V5;
T6 V6;
T7 V7;
T8 V8;
T9 V9;
VTK_M_DEVICE VariantUnionNTD(vtkm::internal::NullType) { }
VariantUnionNTD() = default;
VTK_M_DEVICE ~VariantUnionNTD() { }
};
template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10>
union VariantUnionTD<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>
{
T0 V0;
T1 V1;
T2 V2;
T3 V3;
T4 V4;
T5 V5;
T6 V6;
T7 V7;
T8 V8;
T9 V9;
T10 V10;
VTK_M_DEVICE VariantUnionTD(vtkm::internal::NullType) { }
VariantUnionTD() = default;
};
template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10>
union VariantUnionNTD<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>
{
T0 V0;
T1 V1;
T2 V2;
T3 V3;
T4 V4;
T5 V5;
T6 V6;
T7 V7;
T8 V8;
T9 V9;
T10 V10;
VTK_M_DEVICE VariantUnionNTD(vtkm::internal::NullType) { }
VariantUnionNTD() = default;
VTK_M_DEVICE ~VariantUnionNTD() { }
};
template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11>
union VariantUnionTD<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>
{
T0 V0;
T1 V1;
T2 V2;
T3 V3;
T4 V4;
T5 V5;
T6 V6;
T7 V7;
T8 V8;
T9 V9;
T10 V10;
T11 V11;
VTK_M_DEVICE VariantUnionTD(vtkm::internal::NullType) { }
VariantUnionTD() = default;
};
template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11>
union VariantUnionNTD<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>
{
T0 V0;
T1 V1;
T2 V2;
T3 V3;
T4 V4;
T5 V5;
T6 V6;
T7 V7;
T8 V8;
T9 V9;
T10 V10;
T11 V11;
VTK_M_DEVICE VariantUnionNTD(vtkm::internal::NullType) { }
VariantUnionNTD() = default;
VTK_M_DEVICE ~VariantUnionNTD() { }
};
template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12>
union VariantUnionTD<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>
{
T0 V0;
T1 V1;
T2 V2;
T3 V3;
T4 V4;
T5 V5;
T6 V6;
T7 V7;
T8 V8;
T9 V9;
T10 V10;
T11 V11;
T12 V12;
VTK_M_DEVICE VariantUnionTD(vtkm::internal::NullType) { }
VariantUnionTD() = default;
};
template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12>
union VariantUnionNTD<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>
{
T0 V0;
T1 V1;
T2 V2;
T3 V3;
T4 V4;
T5 V5;
T6 V6;
T7 V7;
T8 V8;
T9 V9;
T10 V10;
T11 V11;
T12 V12;
VTK_M_DEVICE VariantUnionNTD(vtkm::internal::NullType) { }
VariantUnionNTD() = default;
VTK_M_DEVICE ~VariantUnionNTD() { }
};
template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13>
union VariantUnionTD<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>
{
T0 V0;
T1 V1;
T2 V2;
T3 V3;
T4 V4;
T5 V5;
T6 V6;
T7 V7;
T8 V8;
T9 V9;
T10 V10;
T11 V11;
T12 V12;
T13 V13;
VTK_M_DEVICE VariantUnionTD(vtkm::internal::NullType) { }
VariantUnionTD() = default;
};
template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13>
union VariantUnionNTD<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>
{
T0 V0;
T1 V1;
T2 V2;
T3 V3;
T4 V4;
T5 V5;
T6 V6;
T7 V7;
T8 V8;
T9 V9;
T10 V10;
T11 V11;
T12 V12;
T13 V13;
VTK_M_DEVICE VariantUnionNTD(vtkm::internal::NullType) { }
VariantUnionNTD() = default;
VTK_M_DEVICE ~VariantUnionNTD() { }
};
template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14>
union VariantUnionTD<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>
{
T0 V0;
T1 V1;
T2 V2;
T3 V3;
T4 V4;
T5 V5;
T6 V6;
T7 V7;
T8 V8;
T9 V9;
T10 V10;
T11 V11;
T12 V12;
T13 V13;
T14 V14;
VTK_M_DEVICE VariantUnionTD(vtkm::internal::NullType) { }
VariantUnionTD() = default;
};
template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14>
union VariantUnionNTD<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>
{
T0 V0;
T1 V1;
T2 V2;
T3 V3;
T4 V4;
T5 V5;
T6 V6;
T7 V7;
T8 V8;
T9 V9;
T10 V10;
T11 V11;
T12 V12;
T13 V13;
T14 V14;
VTK_M_DEVICE VariantUnionNTD(vtkm::internal::NullType) { }
VariantUnionNTD() = default;
VTK_M_DEVICE ~VariantUnionNTD() { }
};
template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15>
union VariantUnionTD<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>
{
T0 V0;
T1 V1;
T2 V2;
T3 V3;
T4 V4;
T5 V5;
T6 V6;
T7 V7;
T8 V8;
T9 V9;
T10 V10;
T11 V11;
T12 V12;
T13 V13;
T14 V14;
T15 V15;
VTK_M_DEVICE VariantUnionTD(vtkm::internal::NullType) { }
VariantUnionTD() = default;
};
template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15>
union VariantUnionNTD<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>
{
T0 V0;
T1 V1;
T2 V2;
T3 V3;
T4 V4;
T5 V5;
T6 V6;
T7 V7;
T8 V8;
T9 V9;
T10 V10;
T11 V11;
T12 V12;
T13 V13;
T14 V14;
T15 V15;
VTK_M_DEVICE VariantUnionNTD(vtkm::internal::NullType) { }
VariantUnionNTD() = default;
VTK_M_DEVICE ~VariantUnionNTD() { }
};
template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16>
union VariantUnionTD<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>
{
T0 V0;
T1 V1;
T2 V2;
T3 V3;
T4 V4;
T5 V5;
T6 V6;
T7 V7;
T8 V8;
T9 V9;
T10 V10;
T11 V11;
T12 V12;
T13 V13;
T14 V14;
T15 V15;
T16 V16;
VTK_M_DEVICE VariantUnionTD(vtkm::internal::NullType) { }
VariantUnionTD() = default;
};
template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16>
union VariantUnionNTD<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>
{
T0 V0;
T1 V1;
T2 V2;
T3 V3;
T4 V4;
T5 V5;
T6 V6;
T7 V7;
T8 V8;
T9 V9;
T10 V10;
T11 V11;
T12 V12;
T13 V13;
T14 V14;
T15 V15;
T16 V16;
VTK_M_DEVICE VariantUnionNTD(vtkm::internal::NullType) { }
VariantUnionNTD() = default;
VTK_M_DEVICE ~VariantUnionNTD() { }
};
template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17>
union VariantUnionTD<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17>
{
T0 V0;
T1 V1;
T2 V2;
T3 V3;
T4 V4;
T5 V5;
T6 V6;
T7 V7;
T8 V8;
T9 V9;
T10 V10;
T11 V11;
T12 V12;
T13 V13;
T14 V14;
T15 V15;
T16 V16;
T17 V17;
VTK_M_DEVICE VariantUnionTD(vtkm::internal::NullType) { }
VariantUnionTD() = default;
};
template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17>
union VariantUnionNTD<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17>
{
T0 V0;
T1 V1;
T2 V2;
T3 V3;
T4 V4;
T5 V5;
T6 V6;
T7 V7;
T8 V8;
T9 V9;
T10 V10;
T11 V11;
T12 V12;
T13 V13;
T14 V14;
T15 V15;
T16 V16;
T17 V17;
VTK_M_DEVICE VariantUnionNTD(vtkm::internal::NullType) { }
VariantUnionNTD() = default;
VTK_M_DEVICE ~VariantUnionNTD() { }
};
template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18>
union VariantUnionTD<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>
{
T0 V0;
T1 V1;
T2 V2;
T3 V3;
T4 V4;
T5 V5;
T6 V6;
T7 V7;
T8 V8;
T9 V9;
T10 V10;
T11 V11;
T12 V12;
T13 V13;
T14 V14;
T15 V15;
T16 V16;
T17 V17;
T18 V18;
VTK_M_DEVICE VariantUnionTD(vtkm::internal::NullType) { }
VariantUnionTD() = default;
};
template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18>
union VariantUnionNTD<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>
{
T0 V0;
T1 V1;
T2 V2;
T3 V3;
T4 V4;
T5 V5;
T6 V6;
T7 V7;
T8 V8;
T9 V9;
T10 V10;
T11 V11;
T12 V12;
T13 V13;
T14 V14;
T15 V15;
T16 V16;
T17 V17;
T18 V18;
VTK_M_DEVICE VariantUnionNTD(vtkm::internal::NullType) { }
VariantUnionNTD() = default;
VTK_M_DEVICE ~VariantUnionNTD() { }
};
template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18, typename T19>
union VariantUnionTD<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19>
{
T0 V0;
T1 V1;
T2 V2;
T3 V3;
T4 V4;
T5 V5;
T6 V6;
T7 V7;
T8 V8;
T9 V9;
T10 V10;
T11 V11;
T12 V12;
T13 V13;
T14 V14;
T15 V15;
T16 V16;
T17 V17;
T18 V18;
T19 V19;
VTK_M_DEVICE VariantUnionTD(vtkm::internal::NullType) { }
VariantUnionTD() = default;
};
template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18, typename T19>
union VariantUnionNTD<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19>
{
T0 V0;
T1 V1;
T2 V2;
T3 V3;
T4 V4;
T5 V5;
T6 V6;
T7 V7;
T8 V8;
T9 V9;
T10 V10;
T11 V11;
T12 V12;
T13 V13;
T14 V14;
T15 V15;
T16 V16;
T17 V17;
T18 V18;
T19 V19;
VTK_M_DEVICE VariantUnionNTD(vtkm::internal::NullType) { }
VariantUnionNTD() = default;
VTK_M_DEVICE ~VariantUnionNTD() { }
};
template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18, typename T19, typename T20, typename... Ts>
union VariantUnionTD<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, Ts...>
{
vtkm::internal::NullType Dummy;
T0 V0;
T1 V1;
T2 V2;
T3 V3;
T4 V4;
T5 V5;
T6 V6;
T7 V7;
T8 V8;
T9 V9;
T10 V10;
T11 V11;
T12 V12;
T13 V13;
T14 V14;
T15 V15;
T16 V16;
T17 V17;
T18 V18;
T19 V19;
VariantUnionTD<T20, Ts...> Remaining;
VTK_M_DEVICE VariantUnionTD(vtkm::internal::NullType) { }
VariantUnionTD() = default;
};
template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18, typename T19, typename T20, typename... Ts>
union VariantUnionNTD<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, Ts...>
{
vtkm::internal::NullType Dummy;
T0 V0;
T1 V1;
T2 V2;
T3 V3;
T4 V4;
T5 V5;
T6 V6;
T7 V7;
T8 V8;
T9 V9;
T10 V10;
T11 V11;
T12 V12;
T13 V13;
T14 V14;
T15 V15;
T16 V16;
T17 V17;
T18 V18;
T19 V19;
VariantUnionNTD<T20, Ts...> Remaining;
VTK_M_DEVICE VariantUnionNTD(vtkm::internal::NullType) { }
VariantUnionNTD() = default;
VTK_M_DEVICE ~VariantUnionNTD() { }
};
template <bool TrivialConstructor, typename... Ts>
struct VariantUnionFinder;
template <typename... Ts>
struct VariantUnionFinder<true, Ts...>
{
using type = VariantUnionTD<Ts...>;
};
template <typename... Ts>
struct VariantUnionFinder<false, Ts...>
{
using type = VariantUnionNTD<Ts...>;
};
template <typename... Ts>
using VariantUnion =
typename VariantUnionFinder<AllTriviallyDestructible<Ts...>::value, Ts...>::type;
// --------------------------------------------------------------------------------
// Methods to get values out of the variant union
template <vtkm::IdComponent I, typename UnionType>
struct VariantUnionGetImpl;
template <typename UnionType>
struct VariantUnionGetImpl<0, UnionType>
{
Use specialized class instead of function overload for Variant::Get Nvcc was having troubles resolving the return type of the overloaded function to get a value out of a `VariantUnion`. Replace the implementation with a class with specializations. This is more verbose, but easier on the compiler.
2021-03-23 19:30:55 +00:00
using ReturnType = decltype(std::declval<UnionType>().V0);
VTK_M_DEVICE static ReturnType& Get(UnionType& storage) noexcept
{
return storage.V0;
}
VTK_M_DEVICE static const ReturnType& Get(const UnionType& storage) noexcept
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
{
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return storage.V0;
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
}
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
};
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
template <typename UnionType>
struct VariantUnionGetImpl<1, UnionType>
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
{
Use specialized class instead of function overload for Variant::Get Nvcc was having troubles resolving the return type of the overloaded function to get a value out of a `VariantUnion`. Replace the implementation with a class with specializations. This is more verbose, but easier on the compiler.
2021-03-23 19:30:55 +00:00
using ReturnType = decltype(std::declval<UnionType>().V1);
VTK_M_DEVICE static ReturnType& Get(UnionType& storage) noexcept
{
return storage.V1;
}
VTK_M_DEVICE static const ReturnType& Get(const UnionType& storage) noexcept
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
{
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return storage.V1;
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
}
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
};
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
template <typename UnionType>
struct VariantUnionGetImpl<2, UnionType>
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
{
Use specialized class instead of function overload for Variant::Get Nvcc was having troubles resolving the return type of the overloaded function to get a value out of a `VariantUnion`. Replace the implementation with a class with specializations. This is more verbose, but easier on the compiler.
2021-03-23 19:30:55 +00:00
using ReturnType = decltype(std::declval<UnionType>().V2);
VTK_M_DEVICE static ReturnType& Get(UnionType& storage) noexcept
{
return storage.V2;
}
VTK_M_DEVICE static const ReturnType& Get(const UnionType& storage) noexcept
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
{
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return storage.V2;
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
}
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
};
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
template <typename UnionType>
struct VariantUnionGetImpl<3, UnionType>
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
{
Use specialized class instead of function overload for Variant::Get Nvcc was having troubles resolving the return type of the overloaded function to get a value out of a `VariantUnion`. Replace the implementation with a class with specializations. This is more verbose, but easier on the compiler.
2021-03-23 19:30:55 +00:00
using ReturnType = decltype(std::declval<UnionType>().V3);
VTK_M_DEVICE static ReturnType& Get(UnionType& storage) noexcept
{
return storage.V3;
}
VTK_M_DEVICE static const ReturnType& Get(const UnionType& storage) noexcept
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
{
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return storage.V3;
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
}
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
};
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
template <typename UnionType>
struct VariantUnionGetImpl<4, UnionType>
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
{
Use specialized class instead of function overload for Variant::Get Nvcc was having troubles resolving the return type of the overloaded function to get a value out of a `VariantUnion`. Replace the implementation with a class with specializations. This is more verbose, but easier on the compiler.
2021-03-23 19:30:55 +00:00
using ReturnType = decltype(std::declval<UnionType>().V4);
VTK_M_DEVICE static ReturnType& Get(UnionType& storage) noexcept
{
return storage.V4;
}
VTK_M_DEVICE static const ReturnType& Get(const UnionType& storage) noexcept
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
{
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return storage.V4;
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
}
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
};
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
template <typename UnionType>
struct VariantUnionGetImpl<5, UnionType>
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
{
Use specialized class instead of function overload for Variant::Get Nvcc was having troubles resolving the return type of the overloaded function to get a value out of a `VariantUnion`. Replace the implementation with a class with specializations. This is more verbose, but easier on the compiler.
2021-03-23 19:30:55 +00:00
using ReturnType = decltype(std::declval<UnionType>().V5);
VTK_M_DEVICE static ReturnType& Get(UnionType& storage) noexcept
{
return storage.V5;
}
VTK_M_DEVICE static const ReturnType& Get(const UnionType& storage) noexcept
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
{
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return storage.V5;
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
}
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
};
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
template <typename UnionType>
struct VariantUnionGetImpl<6, UnionType>
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
{
Use specialized class instead of function overload for Variant::Get Nvcc was having troubles resolving the return type of the overloaded function to get a value out of a `VariantUnion`. Replace the implementation with a class with specializations. This is more verbose, but easier on the compiler.
2021-03-23 19:30:55 +00:00
using ReturnType = decltype(std::declval<UnionType>().V6);
VTK_M_DEVICE static ReturnType& Get(UnionType& storage) noexcept
{
return storage.V6;
}
VTK_M_DEVICE static const ReturnType& Get(const UnionType& storage) noexcept
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
{
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return storage.V6;
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
}
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
};
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
template <typename UnionType>
struct VariantUnionGetImpl<7, UnionType>
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
{
Use specialized class instead of function overload for Variant::Get Nvcc was having troubles resolving the return type of the overloaded function to get a value out of a `VariantUnion`. Replace the implementation with a class with specializations. This is more verbose, but easier on the compiler.
2021-03-23 19:30:55 +00:00
using ReturnType = decltype(std::declval<UnionType>().V7);
VTK_M_DEVICE static ReturnType& Get(UnionType& storage) noexcept
{
return storage.V7;
}
VTK_M_DEVICE static const ReturnType& Get(const UnionType& storage) noexcept
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
{
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return storage.V7;
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
}
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
};
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
template <typename UnionType>
struct VariantUnionGetImpl<8, UnionType>
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
{
Use specialized class instead of function overload for Variant::Get Nvcc was having troubles resolving the return type of the overloaded function to get a value out of a `VariantUnion`. Replace the implementation with a class with specializations. This is more verbose, but easier on the compiler.
2021-03-23 19:30:55 +00:00
using ReturnType = decltype(std::declval<UnionType>().V8);
VTK_M_DEVICE static ReturnType& Get(UnionType& storage) noexcept
{
return storage.V8;
}
VTK_M_DEVICE static const ReturnType& Get(const UnionType& storage) noexcept
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
{
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return storage.V8;
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
}
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
};
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
template <typename UnionType>
struct VariantUnionGetImpl<9, UnionType>
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
{
Use specialized class instead of function overload for Variant::Get Nvcc was having troubles resolving the return type of the overloaded function to get a value out of a `VariantUnion`. Replace the implementation with a class with specializations. This is more verbose, but easier on the compiler.
2021-03-23 19:30:55 +00:00
using ReturnType = decltype(std::declval<UnionType>().V9);
VTK_M_DEVICE static ReturnType& Get(UnionType& storage) noexcept
{
return storage.V9;
}
VTK_M_DEVICE static const ReturnType& Get(const UnionType& storage) noexcept
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
{
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return storage.V9;
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
}
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
};
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
template <typename UnionType>
struct VariantUnionGetImpl<10, UnionType>
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
{
Use specialized class instead of function overload for Variant::Get Nvcc was having troubles resolving the return type of the overloaded function to get a value out of a `VariantUnion`. Replace the implementation with a class with specializations. This is more verbose, but easier on the compiler.
2021-03-23 19:30:55 +00:00
using ReturnType = decltype(std::declval<UnionType>().V10);
VTK_M_DEVICE static ReturnType& Get(UnionType& storage) noexcept
{
return storage.V10;
}
VTK_M_DEVICE static const ReturnType& Get(const UnionType& storage) noexcept
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
{
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return storage.V10;
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
}
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
};
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
template <typename UnionType>
struct VariantUnionGetImpl<11, UnionType>
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
{
Use specialized class instead of function overload for Variant::Get Nvcc was having troubles resolving the return type of the overloaded function to get a value out of a `VariantUnion`. Replace the implementation with a class with specializations. This is more verbose, but easier on the compiler.
2021-03-23 19:30:55 +00:00
using ReturnType = decltype(std::declval<UnionType>().V11);
VTK_M_DEVICE static ReturnType& Get(UnionType& storage) noexcept
{
return storage.V11;
}
VTK_M_DEVICE static const ReturnType& Get(const UnionType& storage) noexcept
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
{
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return storage.V11;
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
}
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
};
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
template <typename UnionType>
struct VariantUnionGetImpl<12, UnionType>
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
{
Use specialized class instead of function overload for Variant::Get Nvcc was having troubles resolving the return type of the overloaded function to get a value out of a `VariantUnion`. Replace the implementation with a class with specializations. This is more verbose, but easier on the compiler.
2021-03-23 19:30:55 +00:00
using ReturnType = decltype(std::declval<UnionType>().V12);
VTK_M_DEVICE static ReturnType& Get(UnionType& storage) noexcept
{
return storage.V12;
}
VTK_M_DEVICE static const ReturnType& Get(const UnionType& storage) noexcept
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
{
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return storage.V12;
}
};
template <typename UnionType>
struct VariantUnionGetImpl<13, UnionType>
{
Use specialized class instead of function overload for Variant::Get Nvcc was having troubles resolving the return type of the overloaded function to get a value out of a `VariantUnion`. Replace the implementation with a class with specializations. This is more verbose, but easier on the compiler.
2021-03-23 19:30:55 +00:00
using ReturnType = decltype(std::declval<UnionType>().V13);
VTK_M_DEVICE static ReturnType& Get(UnionType& storage) noexcept
{
return storage.V13;
}
VTK_M_DEVICE static const ReturnType& Get(const UnionType& storage) noexcept
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
{
return storage.V13;
}
};
template <typename UnionType>
struct VariantUnionGetImpl<14, UnionType>
{
Use specialized class instead of function overload for Variant::Get Nvcc was having troubles resolving the return type of the overloaded function to get a value out of a `VariantUnion`. Replace the implementation with a class with specializations. This is more verbose, but easier on the compiler.
2021-03-23 19:30:55 +00:00
using ReturnType = decltype(std::declval<UnionType>().V14);
VTK_M_DEVICE static ReturnType& Get(UnionType& storage) noexcept
{
return storage.V14;
}
VTK_M_DEVICE static const ReturnType& Get(const UnionType& storage) noexcept
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
{
return storage.V14;
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
}
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
};
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
template <typename UnionType>
struct VariantUnionGetImpl<15, UnionType>
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
{
Use specialized class instead of function overload for Variant::Get Nvcc was having troubles resolving the return type of the overloaded function to get a value out of a `VariantUnion`. Replace the implementation with a class with specializations. This is more verbose, but easier on the compiler.
2021-03-23 19:30:55 +00:00
using ReturnType = decltype(std::declval<UnionType>().V15);
VTK_M_DEVICE static ReturnType& Get(UnionType& storage) noexcept
{
return storage.V15;
}
VTK_M_DEVICE static const ReturnType& Get(const UnionType& storage) noexcept
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
{
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return storage.V15;
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
}
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
};
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
template <typename UnionType>
struct VariantUnionGetImpl<16, UnionType>
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
{
Use specialized class instead of function overload for Variant::Get Nvcc was having troubles resolving the return type of the overloaded function to get a value out of a `VariantUnion`. Replace the implementation with a class with specializations. This is more verbose, but easier on the compiler.
2021-03-23 19:30:55 +00:00
using ReturnType = decltype(std::declval<UnionType>().V16);
VTK_M_DEVICE static ReturnType& Get(UnionType& storage) noexcept
{
return storage.V16;
}
VTK_M_DEVICE static const ReturnType& Get(const UnionType& storage) noexcept
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
{
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return storage.V16;
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
}
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
};
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
template <typename UnionType>
struct VariantUnionGetImpl<17, UnionType>
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
{
Use specialized class instead of function overload for Variant::Get Nvcc was having troubles resolving the return type of the overloaded function to get a value out of a `VariantUnion`. Replace the implementation with a class with specializations. This is more verbose, but easier on the compiler.
2021-03-23 19:30:55 +00:00
using ReturnType = decltype(std::declval<UnionType>().V17);
VTK_M_DEVICE static ReturnType& Get(UnionType& storage) noexcept
{
return storage.V17;
}
VTK_M_DEVICE static const ReturnType& Get(const UnionType& storage) noexcept
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
{
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return storage.V17;
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
}
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
};
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
template <typename UnionType>
struct VariantUnionGetImpl<18, UnionType>
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
{
Use specialized class instead of function overload for Variant::Get Nvcc was having troubles resolving the return type of the overloaded function to get a value out of a `VariantUnion`. Replace the implementation with a class with specializations. This is more verbose, but easier on the compiler.
2021-03-23 19:30:55 +00:00
using ReturnType = decltype(std::declval<UnionType>().V18);
VTK_M_DEVICE static ReturnType& Get(UnionType& storage) noexcept
{
return storage.V18;
}
VTK_M_DEVICE static const ReturnType& Get(const UnionType& storage) noexcept
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
{
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return storage.V18;
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
}
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
};
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
template <typename UnionType>
struct VariantUnionGetImpl<19, UnionType>
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
{
Use specialized class instead of function overload for Variant::Get Nvcc was having troubles resolving the return type of the overloaded function to get a value out of a `VariantUnion`. Replace the implementation with a class with specializations. This is more verbose, but easier on the compiler.
2021-03-23 19:30:55 +00:00
using ReturnType = decltype(std::declval<UnionType>().V19);
VTK_M_DEVICE static ReturnType& Get(UnionType& storage) noexcept
{
return storage.V19;
}
VTK_M_DEVICE static const ReturnType& Get(const UnionType& storage) noexcept
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
{
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return storage.V19;
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
}
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
};
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
template <vtkm::IdComponent I, typename UnionType>
struct VariantUnionGetImpl
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
{
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
VTKM_STATIC_ASSERT(I >= 20);
Use specialized class instead of function overload for Variant::Get Nvcc was having troubles resolving the return type of the overloaded function to get a value out of a `VariantUnion`. Replace the implementation with a class with specializations. This is more verbose, but easier on the compiler.
2021-03-23 19:30:55 +00:00
using RecursiveGet = VariantUnionGetImpl<I - 20, decltype(std::declval<UnionType&>().Remaining)>;
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
using ReturnType = typename RecursiveGet::ReturnType;
Use specialized class instead of function overload for Variant::Get Nvcc was having troubles resolving the return type of the overloaded function to get a value out of a `VariantUnion`. Replace the implementation with a class with specializations. This is more verbose, but easier on the compiler.
2021-03-23 19:30:55 +00:00
VTK_M_DEVICE static ReturnType& Get(UnionType& storage) noexcept
{
return RecursiveGet::Get(storage.Remaining);
}
VTK_M_DEVICE static const ReturnType& Get(const UnionType& storage) noexcept
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
{
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return RecursiveGet::Get(storage.Remaining);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
}
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
};
template <vtkm::IdComponent I, typename UnionType>
Use specialized class instead of function overload for Variant::Get Nvcc was having troubles resolving the return type of the overloaded function to get a value out of a `VariantUnion`. Replace the implementation with a class with specializations. This is more verbose, but easier on the compiler.
2021-03-23 19:30:55 +00:00
VTK_M_DEVICE auto VariantUnionGet(UnionType& storage) noexcept
-> decltype(VariantUnionGetImpl<I, typename std::decay<UnionType>::type>::Get(storage))&
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
{
Use specialized class instead of function overload for Variant::Get Nvcc was having troubles resolving the return type of the overloaded function to get a value out of a `VariantUnion`. Replace the implementation with a class with specializations. This is more verbose, but easier on the compiler.
2021-03-23 19:30:55 +00:00
return VariantUnionGetImpl<I, typename std::decay<UnionType>::type>::Get(storage);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
}
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
// --------------------------------------------------------------------------------
// Internal implementation of CastAndCall for Variant
template <typename Functor,
typename UnionType,
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
typename... Args>
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
VTK_M_DEVICE inline auto VariantCastAndCallImpl(
std::integral_constant<vtkm::IdComponent, 1>,
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
vtkm::IdComponent index,
Functor&& f,
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
UnionType& storage,
Args&&... args) noexcept(noexcept(f(storage.V0, args...)))
-> decltype(f(storage.V0, args...))
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
{
switch (index)
{
case 0:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V0, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
default:
// If we are here, it means we failed to find the appropriate type in a variant
VTKM_ASSERT(false && "Internal error, bad Variant state.");
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return VariantDummyReturn<decltype(f(storage.V0, args...))>::F();
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
}
}
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
template <typename Functor,
typename UnionType,
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
typename... Args>
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
VTK_M_DEVICE inline auto VariantCastAndCallImpl(
std::integral_constant<vtkm::IdComponent, 2>,
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
vtkm::IdComponent index,
Functor&& f,
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
UnionType& storage,
Args&&... args) noexcept(noexcept(f(storage.V0, args...)))
-> decltype(f(storage.V0, args...))
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
{
switch (index)
{
case 0:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V0, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 1:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V1, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
default:
// If we are here, it means we failed to find the appropriate type in a variant
VTKM_ASSERT(false && "Internal error, bad Variant state.");
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return VariantDummyReturn<decltype(f(storage.V0, args...))>::F();
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
}
}
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
template <typename Functor,
typename UnionType,
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
typename... Args>
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
VTK_M_DEVICE inline auto VariantCastAndCallImpl(
std::integral_constant<vtkm::IdComponent, 3>,
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
vtkm::IdComponent index,
Functor&& f,
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
UnionType& storage,
Args&&... args) noexcept(noexcept(f(storage.V0, args...)))
-> decltype(f(storage.V0, args...))
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
{
switch (index)
{
case 0:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V0, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 1:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V1, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 2:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V2, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
default:
// If we are here, it means we failed to find the appropriate type in a variant
VTKM_ASSERT(false && "Internal error, bad Variant state.");
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return VariantDummyReturn<decltype(f(storage.V0, args...))>::F();
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
}
}
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
template <typename Functor,
typename UnionType,
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
typename... Args>
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
VTK_M_DEVICE inline auto VariantCastAndCallImpl(
std::integral_constant<vtkm::IdComponent, 4>,
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
vtkm::IdComponent index,
Functor&& f,
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
UnionType& storage,
Args&&... args) noexcept(noexcept(f(storage.V0, args...)))
-> decltype(f(storage.V0, args...))
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
{
switch (index)
{
case 0:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V0, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 1:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V1, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 2:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V2, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 3:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V3, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
default:
// If we are here, it means we failed to find the appropriate type in a variant
VTKM_ASSERT(false && "Internal error, bad Variant state.");
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return VariantDummyReturn<decltype(f(storage.V0, args...))>::F();
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
}
}
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
template <typename Functor,
typename UnionType,
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
typename... Args>
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
VTK_M_DEVICE inline auto VariantCastAndCallImpl(
std::integral_constant<vtkm::IdComponent, 5>,
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
vtkm::IdComponent index,
Functor&& f,
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
UnionType& storage,
Args&&... args) noexcept(noexcept(f(storage.V0, args...)))
-> decltype(f(storage.V0, args...))
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
{
switch (index)
{
case 0:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V0, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 1:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V1, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 2:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V2, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 3:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V3, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 4:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V4, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
default:
// If we are here, it means we failed to find the appropriate type in a variant
VTKM_ASSERT(false && "Internal error, bad Variant state.");
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return VariantDummyReturn<decltype(f(storage.V0, args...))>::F();
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
}
}
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
template <typename Functor,
typename UnionType,
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
typename... Args>
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
VTK_M_DEVICE inline auto VariantCastAndCallImpl(
std::integral_constant<vtkm::IdComponent, 6>,
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
vtkm::IdComponent index,
Functor&& f,
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
UnionType& storage,
Args&&... args) noexcept(noexcept(f(storage.V0, args...)))
-> decltype(f(storage.V0, args...))
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
{
switch (index)
{
case 0:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V0, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 1:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V1, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 2:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V2, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 3:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V3, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 4:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V4, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 5:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V5, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
default:
// If we are here, it means we failed to find the appropriate type in a variant
VTKM_ASSERT(false && "Internal error, bad Variant state.");
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return VariantDummyReturn<decltype(f(storage.V0, args...))>::F();
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
}
}
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
template <typename Functor,
typename UnionType,
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
typename... Args>
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
VTK_M_DEVICE inline auto VariantCastAndCallImpl(
std::integral_constant<vtkm::IdComponent, 7>,
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
vtkm::IdComponent index,
Functor&& f,
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
UnionType& storage,
Args&&... args) noexcept(noexcept(f(storage.V0, args...)))
-> decltype(f(storage.V0, args...))
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
{
switch (index)
{
case 0:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V0, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 1:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V1, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 2:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V2, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 3:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V3, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 4:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V4, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 5:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V5, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 6:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V6, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
default:
// If we are here, it means we failed to find the appropriate type in a variant
VTKM_ASSERT(false && "Internal error, bad Variant state.");
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return VariantDummyReturn<decltype(f(storage.V0, args...))>::F();
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
}
}
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
template <typename Functor,
typename UnionType,
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
typename... Args>
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
VTK_M_DEVICE inline auto VariantCastAndCallImpl(
std::integral_constant<vtkm::IdComponent, 8>,
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
vtkm::IdComponent index,
Functor&& f,
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
UnionType& storage,
Args&&... args) noexcept(noexcept(f(storage.V0, args...)))
-> decltype(f(storage.V0, args...))
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
{
switch (index)
{
case 0:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V0, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 1:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V1, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 2:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V2, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 3:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V3, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 4:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V4, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 5:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V5, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 6:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V6, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 7:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V7, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
default:
// If we are here, it means we failed to find the appropriate type in a variant
VTKM_ASSERT(false && "Internal error, bad Variant state.");
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return VariantDummyReturn<decltype(f(storage.V0, args...))>::F();
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
}
}
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
template <typename Functor,
typename UnionType,
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
typename... Args>
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
VTK_M_DEVICE inline auto VariantCastAndCallImpl(
std::integral_constant<vtkm::IdComponent, 9>,
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
vtkm::IdComponent index,
Functor&& f,
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
UnionType& storage,
Args&&... args) noexcept(noexcept(f(storage.V0, args...)))
-> decltype(f(storage.V0, args...))
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
{
switch (index)
{
case 0:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V0, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 1:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V1, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 2:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V2, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 3:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V3, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 4:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V4, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 5:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V5, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 6:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V6, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 7:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V7, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 8:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V8, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
default:
// If we are here, it means we failed to find the appropriate type in a variant
VTKM_ASSERT(false && "Internal error, bad Variant state.");
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return VariantDummyReturn<decltype(f(storage.V0, args...))>::F();
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
}
}
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
template <typename Functor,
typename UnionType,
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
typename... Args>
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
VTK_M_DEVICE inline auto VariantCastAndCallImpl(
std::integral_constant<vtkm::IdComponent, 10>,
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
vtkm::IdComponent index,
Functor&& f,
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
UnionType& storage,
Args&&... args) noexcept(noexcept(f(storage.V0, args...)))
-> decltype(f(storage.V0, args...))
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
{
switch (index)
{
case 0:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V0, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 1:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V1, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 2:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V2, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 3:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V3, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 4:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V4, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 5:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V5, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 6:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V6, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 7:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V7, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 8:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V8, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 9:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V9, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
default:
// If we are here, it means we failed to find the appropriate type in a variant
VTKM_ASSERT(false && "Internal error, bad Variant state.");
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return VariantDummyReturn<decltype(f(storage.V0, args...))>::F();
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
}
}
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
template <typename Functor,
typename UnionType,
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
typename... Args>
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
VTK_M_DEVICE inline auto VariantCastAndCallImpl(
std::integral_constant<vtkm::IdComponent, 11>,
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
vtkm::IdComponent index,
Functor&& f,
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
UnionType& storage,
Args&&... args) noexcept(noexcept(f(storage.V0, args...)))
-> decltype(f(storage.V0, args...))
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
{
switch (index)
{
case 0:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V0, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 1:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V1, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 2:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V2, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 3:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V3, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 4:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V4, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 5:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V5, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 6:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V6, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 7:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V7, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 8:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V8, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 9:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V9, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 10:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V10, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
default:
// If we are here, it means we failed to find the appropriate type in a variant
VTKM_ASSERT(false && "Internal error, bad Variant state.");
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return VariantDummyReturn<decltype(f(storage.V0, args...))>::F();
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
}
}
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
template <typename Functor,
typename UnionType,
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
typename... Args>
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
VTK_M_DEVICE inline auto VariantCastAndCallImpl(
std::integral_constant<vtkm::IdComponent, 12>,
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
vtkm::IdComponent index,
Functor&& f,
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
UnionType& storage,
Args&&... args) noexcept(noexcept(f(storage.V0, args...)))
-> decltype(f(storage.V0, args...))
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
{
switch (index)
{
case 0:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V0, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 1:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V1, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 2:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V2, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 3:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V3, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 4:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V4, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 5:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V5, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 6:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V6, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 7:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V7, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 8:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V8, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 9:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V9, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 10:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V10, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 11:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V11, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
default:
// If we are here, it means we failed to find the appropriate type in a variant
VTKM_ASSERT(false && "Internal error, bad Variant state.");
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return VariantDummyReturn<decltype(f(storage.V0, args...))>::F();
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
}
}
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
template <typename Functor,
typename UnionType,
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
typename... Args>
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
VTK_M_DEVICE inline auto VariantCastAndCallImpl(
std::integral_constant<vtkm::IdComponent, 13>,
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
vtkm::IdComponent index,
Functor&& f,
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
UnionType& storage,
Args&&... args) noexcept(noexcept(f(storage.V0, args...)))
-> decltype(f(storage.V0, args...))
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
{
switch (index)
{
case 0:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V0, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 1:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V1, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 2:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V2, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 3:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V3, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 4:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V4, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 5:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V5, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 6:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V6, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 7:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V7, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 8:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V8, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 9:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V9, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 10:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V10, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 11:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V11, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 12:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V12, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
default:
// If we are here, it means we failed to find the appropriate type in a variant
VTKM_ASSERT(false && "Internal error, bad Variant state.");
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return VariantDummyReturn<decltype(f(storage.V0, args...))>::F();
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
}
}
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
template <typename Functor,
typename UnionType,
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
typename... Args>
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
VTK_M_DEVICE inline auto VariantCastAndCallImpl(
std::integral_constant<vtkm::IdComponent, 14>,
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
vtkm::IdComponent index,
Functor&& f,
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
UnionType& storage,
Args&&... args) noexcept(noexcept(f(storage.V0, args...)))
-> decltype(f(storage.V0, args...))
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
{
switch (index)
{
case 0:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V0, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 1:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V1, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 2:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V2, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 3:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V3, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 4:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V4, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 5:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V5, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 6:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V6, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 7:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V7, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 8:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V8, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 9:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V9, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 10:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V10, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 11:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V11, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 12:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V12, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 13:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V13, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
default:
// If we are here, it means we failed to find the appropriate type in a variant
VTKM_ASSERT(false && "Internal error, bad Variant state.");
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return VariantDummyReturn<decltype(f(storage.V0, args...))>::F();
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
}
}
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
template <typename Functor,
typename UnionType,
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
typename... Args>
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
VTK_M_DEVICE inline auto VariantCastAndCallImpl(
std::integral_constant<vtkm::IdComponent, 15>,
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
vtkm::IdComponent index,
Functor&& f,
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
UnionType& storage,
Args&&... args) noexcept(noexcept(f(storage.V0, args...)))
-> decltype(f(storage.V0, args...))
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
{
switch (index)
{
case 0:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V0, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 1:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V1, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 2:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V2, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 3:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V3, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 4:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V4, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 5:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V5, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 6:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V6, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 7:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V7, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 8:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V8, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 9:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V9, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 10:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V10, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 11:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V11, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 12:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V12, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 13:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V13, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 14:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V14, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
default:
// If we are here, it means we failed to find the appropriate type in a variant
VTKM_ASSERT(false && "Internal error, bad Variant state.");
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return VariantDummyReturn<decltype(f(storage.V0, args...))>::F();
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
}
}
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
template <typename Functor,
typename UnionType,
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
typename... Args>
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
VTK_M_DEVICE inline auto VariantCastAndCallImpl(
std::integral_constant<vtkm::IdComponent, 16>,
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
vtkm::IdComponent index,
Functor&& f,
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
UnionType& storage,
Args&&... args) noexcept(noexcept(f(storage.V0, args...)))
-> decltype(f(storage.V0, args...))
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
{
switch (index)
{
case 0:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V0, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 1:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V1, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 2:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V2, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 3:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V3, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 4:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V4, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 5:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V5, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 6:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V6, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 7:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V7, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 8:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V8, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 9:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V9, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 10:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V10, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 11:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V11, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 12:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V12, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 13:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V13, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 14:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V14, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 15:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V15, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
default:
// If we are here, it means we failed to find the appropriate type in a variant
VTKM_ASSERT(false && "Internal error, bad Variant state.");
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return VariantDummyReturn<decltype(f(storage.V0, args...))>::F();
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
}
}
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
template <typename Functor,
typename UnionType,
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
typename... Args>
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
VTK_M_DEVICE inline auto VariantCastAndCallImpl(
std::integral_constant<vtkm::IdComponent, 17>,
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
vtkm::IdComponent index,
Functor&& f,
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
UnionType& storage,
Args&&... args) noexcept(noexcept(f(storage.V0, args...)))
-> decltype(f(storage.V0, args...))
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
{
switch (index)
{
case 0:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V0, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 1:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V1, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 2:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V2, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 3:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V3, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 4:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V4, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 5:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V5, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 6:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V6, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 7:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V7, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 8:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V8, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 9:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V9, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 10:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V10, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 11:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V11, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 12:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V12, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 13:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V13, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 14:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V14, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 15:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V15, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 16:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V16, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
default:
// If we are here, it means we failed to find the appropriate type in a variant
VTKM_ASSERT(false && "Internal error, bad Variant state.");
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return VariantDummyReturn<decltype(f(storage.V0, args...))>::F();
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
}
}
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
template <typename Functor,
typename UnionType,
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
typename... Args>
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
VTK_M_DEVICE inline auto VariantCastAndCallImpl(
std::integral_constant<vtkm::IdComponent, 18>,
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
vtkm::IdComponent index,
Functor&& f,
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
UnionType& storage,
Args&&... args) noexcept(noexcept(f(storage.V0, args...)))
-> decltype(f(storage.V0, args...))
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
{
switch (index)
{
case 0:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V0, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 1:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V1, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 2:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V2, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 3:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V3, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 4:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V4, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 5:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V5, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 6:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V6, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 7:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V7, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 8:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V8, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 9:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V9, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 10:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V10, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 11:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V11, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 12:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V12, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 13:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V13, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 14:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V14, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 15:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V15, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 16:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V16, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 17:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V17, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
default:
// If we are here, it means we failed to find the appropriate type in a variant
VTKM_ASSERT(false && "Internal error, bad Variant state.");
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return VariantDummyReturn<decltype(f(storage.V0, args...))>::F();
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
}
}
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
template <typename Functor,
typename UnionType,
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
typename... Args>
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
VTK_M_DEVICE inline auto VariantCastAndCallImpl(
std::integral_constant<vtkm::IdComponent, 19>,
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
vtkm::IdComponent index,
Functor&& f,
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
UnionType& storage,
Args&&... args) noexcept(noexcept(f(storage.V0, args...)))
-> decltype(f(storage.V0, args...))
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
{
switch (index)
{
case 0:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V0, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 1:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V1, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 2:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V2, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 3:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V3, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 4:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V4, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 5:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V5, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 6:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V6, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 7:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V7, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 8:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V8, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 9:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V9, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 10:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V10, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 11:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V11, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 12:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V12, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 13:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V13, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 14:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V14, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 15:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V15, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 16:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V16, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 17:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V17, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 18:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V18, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
default:
// If we are here, it means we failed to find the appropriate type in a variant
VTKM_ASSERT(false && "Internal error, bad Variant state.");
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return VariantDummyReturn<decltype(f(storage.V0, args...))>::F();
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
}
}
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
template <typename Functor,
typename UnionType,
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
typename... Args>
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
VTK_M_DEVICE inline auto VariantCastAndCallImpl(
std::integral_constant<vtkm::IdComponent, 20>,
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
vtkm::IdComponent index,
Functor&& f,
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
UnionType& storage,
Args&&... args) noexcept(noexcept(f(storage.V0, args...)))
-> decltype(f(storage.V0, args...))
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
{
switch (index)
{
case 0:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V0, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 1:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V1, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 2:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V2, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 3:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V3, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 4:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V4, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 5:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V5, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 6:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V6, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 7:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V7, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 8:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V8, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 9:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V9, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 10:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V10, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 11:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V11, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 12:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V12, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 13:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V13, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 14:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V14, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 15:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V15, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 16:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V16, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 17:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V17, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 18:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V18, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 19:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V19, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
default:
// If we are here, it means we failed to find the appropriate type in a variant
VTKM_ASSERT(false && "Internal error, bad Variant state.");
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return VariantDummyReturn<decltype(f(storage.V0, args...))>::F();
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
}
}
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
//clang-format on
// Recurse for cases where Variant has more than 20 types
template <vtkm::IdComponent N,
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
typename Functor,
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
typename UnionType,
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
typename... Args>
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
VTK_M_DEVICE inline auto VariantCastAndCallImpl(
std::integral_constant<vtkm::IdComponent, N>,
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
vtkm::IdComponent index,
Functor&& f,
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
UnionType& storage,
Args&&... args) noexcept(noexcept(f(storage.V0, args...)))
-> decltype(f(storage.V0, args...))
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
{
switch (index)
{
case 0:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V0, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 1:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V1, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 2:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V2, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 3:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V3, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 4:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V4, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 5:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V5, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 6:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V6, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 7:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V7, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 8:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V8, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 9:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V9, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 10:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V10, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 11:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V11, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 12:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V12, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 13:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V13, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 14:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V14, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 15:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V15, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 16:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V16, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 17:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V17, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 18:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V18, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
case 19:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return f(storage.V19, std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
default:
Use a union in Variant for safe type punning Create a `VaraintUnion` that is an actual C++ `union` to store the data in a `Variant`. You may be asking yourself, why not just use an `std::aligned_union` rather than a real union type? That was our first implementation, but the problem is that the `std::aligned_union` reference needs to be recast to the actual type. Typically you would do that with `reinterpret_cast`. However, doing that leads to undefined behavior. The C++ compiler assumes that 2 pointers of different types point to different memory (even if it is clear that they are set to the same address). That means optimizers can remove code because it "knows" that data in one type cannot affect data in another type. To safely change the type of an `std::aligned_union`, you really have to do an `std::memcpy`. This is problematic for types that cannot be trivially copied. Another problem is that we found that device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
2021-03-17 20:38:33 +00:00
return VariantCastAndCallImpl(std::integral_constant<vtkm::IdComponent, N - 20>{},
index - 20,
std::forward<Functor>(f),
storage.Remaining,
std::forward<Args>(args)...);
Use large case statements to CastAndCall variants Previously, templates were used in the implementation of CastAndCall to find the type and call the underlying function. The templates checked one type at a time. However, compilers were not always great at optimizing a 15-call deep stack with an if statement at each one. Instead, use a case statement in a single function block. This requires providing separate code for each number of types. Currently, up to 20 are created (with pyexpander). If there are more than that, then the template recurses.
2019-07-22 19:56:35 +00:00
}
}
}
}
Make separate exec and cont versions of Variant The `Variant` class is templated to hold objects of other types. Depending on whether those objects of are meant to be used in the control or execution side, the methods on `Variant` might need to be declared with (or without) special modifiers. We can sometimes try to compile the `Variant` methods for both host and device and ask the device compiler to ignore incompatibilities, but that does not always work. To get around that, create two different implementations of `Variant`. Their API and implementation is exactly the same except one declares its methods with `VTKM_CONT` and the other its methods `VTKM_EXEC`.
2020-10-06 21:57:04 +00:00
}
} // vtkm::VTK_M_NAMESPACE::internal::detail
Reference in New Issue Copy Permalink