Commit ee69c7a4 authored by Robert Maynard's avatar Robert Maynard

Remove VS2013 workarounds from VTK-m.

parent 01c9d6e2
...@@ -86,12 +86,6 @@ function(vtkm_setup_msvc_properties target ) ...@@ -86,12 +86,6 @@ function(vtkm_setup_msvc_properties target )
# removed when doing header test builds. # removed when doing header test builds.
target_compile_options(${target} PRIVATE -wd4702 -wd4505) target_compile_options(${target} PRIVATE -wd4702 -wd4505)
# In VS2013 the C4127 warning has a bug in the implementation and
# generates false positive warnings for lots of template code
if(MSVC_VERSION LESS 1900)
target_compile_options(${target} PRIVATE -wd4127 )
endif()
endfunction(vtkm_setup_msvc_properties) endfunction(vtkm_setup_msvc_properties)
# vtkm_target_name(<name>) # vtkm_target_name(<name>)
......
...@@ -61,7 +61,7 @@ VTK-m Requires: ...@@ -61,7 +61,7 @@ VTK-m Requires:
+ GCC 4.8+ + GCC 4.8+
+ Clang 3.3+ + Clang 3.3+
+ XCode 5.0+ + XCode 5.0+
+ MSVC 2013+ + MSVC 2015+
+ [CMake](http://www.cmake.org/download/) + [CMake](http://www.cmake.org/download/)
+ CMake 3.3+ (for any build) + CMake 3.3+ (for any build)
+ CMake 3.9+ (for CUDA build) + CMake 3.9+ (for CUDA build)
......
...@@ -168,8 +168,7 @@ class ExposedClass; ...@@ -168,8 +168,7 @@ class ExposedClass;
namespace references are preferred). namespace references are preferred).
+ All code must be valid by the C++11 specifications. It must also + All code must be valid by the C++11 specifications. It must also
compile correctly with Microsoft Visual Studio 2013, which implements a compile with Microsoft Visual Studio 2015.
subset of the C++11 standard.
+ New code must include regression tests that will run on the dashboards. + New code must include regression tests that will run on the dashboards.
Generally a new class will have an associated "UnitTest" that will test Generally a new class will have an associated "UnitTest" that will test
......
...@@ -36,7 +36,7 @@ namespace internal ...@@ -36,7 +36,7 @@ namespace internal
template <typename ListTag> template <typename ListTag>
struct ListTagCheck : std::is_base_of<vtkm::detail::ListRoot, ListTag> struct ListTagCheck : std::is_base_of<vtkm::detail::ListRoot, ListTag>
{ {
static VTKM_CONSTEXPR bool Valid = std::is_base_of<vtkm::detail::ListRoot, ListTag>::value; static constexpr bool Valid = std::is_base_of<vtkm::detail::ListRoot, ListTag>::value;
}; };
} // namespace internal } // namespace internal
...@@ -111,7 +111,7 @@ template <typename ListTag, typename Type> ...@@ -111,7 +111,7 @@ template <typename ListTag, typename Type>
struct ListContains struct ListContains
{ {
VTKM_IS_LIST_TAG(ListTag); VTKM_IS_LIST_TAG(ListTag);
static VTKM_CONSTEXPR bool value = detail::ListContainsImpl<Type, typename ListTag::list>::value; static constexpr bool value = detail::ListContainsImpl<Type, typename ListTag::list>::value;
}; };
} // namespace vtkm } // namespace vtkm
......
...@@ -87,7 +87,7 @@ struct ArrayHandleSwizzleTraits ...@@ -87,7 +87,7 @@ struct ArrayHandleSwizzleTraits
/// A std::array containing the ComponentMap for runtime querying. /// A std::array containing the ComponentMap for runtime querying.
using RuntimeComponentMapType = std::array<vtkm::IdComponent, COUNT>; using RuntimeComponentMapType = std::array<vtkm::IdComponent, COUNT>;
static VTKM_CONSTEXPR RuntimeComponentMapType GenerateRuntimeComponentMap() static constexpr RuntimeComponentMapType GenerateRuntimeComponentMap()
{ {
return RuntimeComponentMapType{ { ComponentMap... } }; return RuntimeComponentMapType{ { ComponentMap... } };
} }
...@@ -124,7 +124,7 @@ private: ...@@ -124,7 +124,7 @@ private:
template <vtkm::IdComponent OutputIndex, vtkm::IdComponent Head> template <vtkm::IdComponent OutputIndex, vtkm::IdComponent Head>
struct GetImpl<OutputIndex, Head> struct GetImpl<OutputIndex, Head>
{ {
VTKM_CONSTEXPR vtkm::IdComponent operator()() const { return OutputIndex == 0 ? Head : -1; } constexpr vtkm::IdComponent operator()() const { return OutputIndex == 0 ? Head : -1; }
}; };
// Recursive case: // Recursive case:
...@@ -133,17 +133,14 @@ private: ...@@ -133,17 +133,14 @@ private:
{ {
using Next = GetImpl<OutputIndex - 1, Tail...>; using Next = GetImpl<OutputIndex - 1, Tail...>;
VTKM_CONSTEXPR vtkm::IdComponent operator()() const constexpr vtkm::IdComponent operator()() const { return OutputIndex == 0 ? Head : Next()(); }
{
return OutputIndex == 0 ? Head : Next()();
}
}; };
public: public:
/// Get the component from ComponentMap at the specified index as a /// Get the component from ComponentMap at the specified index as a
/// compile-time constant: /// compile-time constant:
template <vtkm::IdComponent OutputIndex> template <vtkm::IdComponent OutputIndex>
static VTKM_CONSTEXPR vtkm::IdComponent Get() static constexpr vtkm::IdComponent Get()
{ {
return GetImpl<OutputIndex, ComponentMap...>()(); return GetImpl<OutputIndex, ComponentMap...>()();
} }
......
...@@ -183,15 +183,7 @@ template <typename ArrayHandleType, ...@@ -183,15 +183,7 @@ template <typename ArrayHandleType,
typename InverseFunctorType = NullFunctorType> typename InverseFunctorType = NullFunctorType>
struct VTKM_ALWAYS_EXPORT StorageTagTransform struct VTKM_ALWAYS_EXPORT StorageTagTransform
{ {
#if defined(VTKM_MSVC) && (_MSC_VER == 1800) // workaround for VS2013
private:
using ArrayHandleValueType = typename ArrayHandleType::ValueType;
public:
using ValueType = decltype(FunctorType{}(ArrayHandleValueType{}));
#else
using ValueType = decltype(FunctorType{}(typename ArrayHandleType::ValueType{})); using ValueType = decltype(FunctorType{}(typename ArrayHandleType::ValueType{}));
#endif
}; };
template <typename ArrayHandleType, typename FunctorType> template <typename ArrayHandleType, typename FunctorType>
......
...@@ -27,7 +27,7 @@ ...@@ -27,7 +27,7 @@
#include <exception> #include <exception>
#include <string> #include <string>
#include <vtkm/internal/ExportMacros.h> // For VTKM_NOEXCEPT #include <vtkm/internal/ExportMacros.h>
namespace vtkm namespace vtkm
{ {
...@@ -55,7 +55,7 @@ public: ...@@ -55,7 +55,7 @@ public:
#endif #endif
// For std::exception compatibility: // For std::exception compatibility:
const char* what() const VTKM_NOEXCEPT override { return this->Message.c_str(); } const char* what() const noexcept override { return this->Message.c_str(); }
protected: protected:
Error() {} Error() {}
......
...@@ -53,7 +53,7 @@ namespace internal ...@@ -53,7 +53,7 @@ namespace internal
template <typename ControlSignatureTag> template <typename ControlSignatureTag>
struct ControlSignatureTagCheck struct ControlSignatureTagCheck
{ {
static VTKM_CONSTEXPR bool Valid = static constexpr bool Valid =
std::is_base_of<vtkm::cont::arg::ControlSignatureTagBase, ControlSignatureTag>::value; std::is_base_of<vtkm::cont::arg::ControlSignatureTagBase, ControlSignatureTag>::value;
}; };
......
...@@ -46,7 +46,7 @@ struct TypeCheckTagExecObject ...@@ -46,7 +46,7 @@ struct TypeCheckTagExecObject
template <typename Type> template <typename Type>
struct TypeCheck<TypeCheckTagExecObject, Type> struct TypeCheck<TypeCheckTagExecObject, Type>
{ {
static VTKM_CONSTEXPR bool value = std::is_base_of<vtkm::exec::ExecutionObjectBase, Type>::value; static constexpr bool value = std::is_base_of<vtkm::exec::ExecutionObjectBase, Type>::value;
}; };
} }
} }
......
...@@ -433,7 +433,7 @@ public: ...@@ -433,7 +433,7 @@ public:
const BinaryCompare& binary_compare) const BinaryCompare& binary_compare)
{ {
internal::WrappedBinaryOperator<bool, BinaryCompare> wrappedCompare(binary_compare); internal::WrappedBinaryOperator<bool, BinaryCompare> wrappedCompare(binary_compare);
VTKM_CONSTEXPR bool larger_than_64bits = sizeof(U) > sizeof(vtkm::Int64); constexpr bool larger_than_64bits = sizeof(U) > sizeof(vtkm::Int64);
if (larger_than_64bits) if (larger_than_64bits)
{ {
/// More efficient sort: /// More efficient sort:
......
...@@ -195,7 +195,7 @@ void parallel_sort_bykey(vtkm::cont::ArrayHandle<T, StorageT>& keys, ...@@ -195,7 +195,7 @@ void parallel_sort_bykey(vtkm::cont::ArrayHandle<T, StorageT>& keys,
PSortTag) PSortTag)
{ {
using KeyType = vtkm::cont::ArrayHandle<T, StorageT>; using KeyType = vtkm::cont::ArrayHandle<T, StorageT>;
VTKM_CONSTEXPR bool larger_than_64bits = sizeof(U) > sizeof(vtkm::Int64); constexpr bool larger_than_64bits = sizeof(U) > sizeof(vtkm::Int64);
if (larger_than_64bits) if (larger_than_64bits)
{ {
/// More efficient sort: /// More efficient sort:
......
...@@ -129,8 +129,8 @@ inline vtkm::filter::Result Gradient::DoExecute( ...@@ -129,8 +129,8 @@ inline vtkm::filter::Result Gradient::DoExecute(
transpose_3x3(outArray, adapter); transpose_3x3(outArray, adapter);
} }
VTKM_CONSTEXPR bool isVector = std::is_same<typename vtkm::VecTraits<T>::HasMultipleComponents, constexpr bool isVector = std::is_same<typename vtkm::VecTraits<T>::HasMultipleComponents,
vtkm::VecTraitsTagMultipleComponents>::value; vtkm::VecTraitsTagMultipleComponents>::value;
vtkm::cont::Field::AssociationEnum fieldAssociation(this->ComputePointGradient vtkm::cont::Field::AssociationEnum fieldAssociation(this->ComputePointGradient
? vtkm::cont::Field::ASSOC_POINTS ? vtkm::cont::Field::ASSOC_POINTS
......
...@@ -272,7 +272,7 @@ ...@@ -272,7 +272,7 @@
#cmakedefine VTKM_ENABLE_MPI #cmakedefine VTKM_ENABLE_MPI
#if __cplusplus >= 201103L || \ #if __cplusplus >= 201103L || \
( defined(VTKM_MSVC) && _MSC_VER >= 1800 ) || \ ( defined(VTKM_MSVC) && _MSC_VER >= 1900 ) || \
( defined(VTKM_ICC) && defined(__INTEL_CXX11_MODE__) ) ( defined(VTKM_ICC) && defined(__INTEL_CXX11_MODE__) )
#define VTKM_HAVE_CXX_11 #define VTKM_HAVE_CXX_11
#else #else
...@@ -340,17 +340,6 @@ ...@@ -340,17 +340,6 @@
// //
#pragma warning(disable:4251) #pragma warning(disable:4251)
// MSVC 2013 and earlier only:
#if _MSC_VER <= 1800
// Generates numerous warnings that implicit constructors can't
// be constructed. This is understood and we don't care.
#pragma warning(disable:4510)
// Generates numerous warnings that implicit assignment operators can't
// be constructed. This is understood and we don't care.
#pragma warning(disable:4512)
#endif // MSVC <= 2013
#endif #endif
#endif //vtkm_internal_Configure_h #endif //vtkm_internal_Configure_h
...@@ -77,16 +77,6 @@ ...@@ -77,16 +77,6 @@
#define VTKM_NEVER_EXPORT __attribute__((visibility("hidden"))) #define VTKM_NEVER_EXPORT __attribute__((visibility("hidden")))
#endif #endif
// constexpr support was added to VisualStudio 2015 and above. So this makes
// sure when that we gracefully fall back to just const when using 2013
#if defined(VTKM_MSVC) && _MSC_VER < 1900
#define VTKM_CONSTEXPR const
#define VTKM_NOEXCEPT
#else
#define VTKM_CONSTEXPR constexpr
#define VTKM_NOEXCEPT noexcept
#endif
// Clang will warn about weak vtables (-Wweak-vtables) on exception classes, // Clang will warn about weak vtables (-Wweak-vtables) on exception classes,
// but there's no good way to eliminate them in this case because MSVC (See // but there's no good way to eliminate them in this case because MSVC (See
// http://stackoverflow.com/questions/24511376). These macros will silence the // http://stackoverflow.com/questions/24511376). These macros will silence the
......
...@@ -389,7 +389,7 @@ public: ...@@ -389,7 +389,7 @@ public:
{ {
this->Result = src.GetReturnValueSafe(); this->Result = src.GetReturnValueSafe();
VTKM_CONSTEXPR vtkm::UInt16 minArity = (ARITY < FunctionInterface<SrcFunctionSignature>::ARITY) constexpr vtkm::UInt16 minArity = (ARITY < FunctionInterface<SrcFunctionSignature>::ARITY)
? ARITY ? ARITY
: FunctionInterface<SrcFunctionSignature>::ARITY; : FunctionInterface<SrcFunctionSignature>::ARITY;
...@@ -774,8 +774,8 @@ public: ...@@ -774,8 +774,8 @@ public:
using interfaceSig = typename detail::AsSigType<appended>::type; using interfaceSig = typename detail::AsSigType<appended>::type;
using NextInterfaceType = FunctionInterface<interfaceSig>; using NextInterfaceType = FunctionInterface<interfaceSig>;
static VTKM_CONSTEXPR std::size_t newArity = NextInterfaceType::ARITY; static constexpr std::size_t newArity = NextInterfaceType::ARITY;
static VTKM_CONSTEXPR std::size_t oldArity = detail::FunctionSigInfo<OriginalFunction>::Arity; static constexpr std::size_t oldArity = detail::FunctionSigInfo<OriginalFunction>::Arity;
typedef std::integral_constant<bool, (newArity < oldArity)> ShouldDoNextTransformType; typedef std::integral_constant<bool, (newArity < oldArity)> ShouldDoNextTransformType;
NextInterfaceType nextInterface = this->NewInterface.Append(newParameter); NextInterfaceType nextInterface = this->NewInterface.Append(newParameter);
......
...@@ -50,14 +50,14 @@ template <typename T> ...@@ -50,14 +50,14 @@ template <typename T>
struct FunctionInterfaceReturnContainer struct FunctionInterfaceReturnContainer
{ {
T Value; T Value;
static VTKM_CONSTEXPR bool VALID = true; static constexpr bool VALID = true;
}; };
template <> template <>
struct FunctionInterfaceReturnContainer<void> struct FunctionInterfaceReturnContainer<void>
{ {
// Nothing to store for void return. // Nothing to store for void return.
static VTKM_CONSTEXPR bool VALID = false; static constexpr bool VALID = false;
}; };
namespace detail namespace detail
...@@ -648,7 +648,7 @@ struct FunctionSigInfo; ...@@ -648,7 +648,7 @@ struct FunctionSigInfo;
template <typename R, typename... ArgTypes> template <typename R, typename... ArgTypes>
struct FunctionSigInfo<R(ArgTypes...)> struct FunctionSigInfo<R(ArgTypes...)>
{ {
static VTKM_CONSTEXPR std::size_t Arity = sizeof...(ArgTypes); static constexpr std::size_t Arity = sizeof...(ArgTypes);
using ArityType = std::integral_constant<int, static_cast<int>(Arity)>; using ArityType = std::integral_constant<int, static_cast<int>(Arity)>;
using ResultType = R; using ResultType = R;
......
...@@ -96,14 +96,14 @@ template <typename T> ...@@ -96,14 +96,14 @@ template <typename T>
struct FunctionInterfaceReturnContainer struct FunctionInterfaceReturnContainer
{ {
T Value; T Value;
static VTKM_CONSTEXPR bool VALID = true; static constexpr bool VALID = true;
}; };
template <> template <>
struct FunctionInterfaceReturnContainer<void> struct FunctionInterfaceReturnContainer<void>
{ {
// Nothing to store for void return. // Nothing to store for void return.
static VTKM_CONSTEXPR bool VALID = false; static constexpr bool VALID = false;
}; };
namespace detail namespace detail
...@@ -139,7 +139,7 @@ struct FunctionSigInfo; ...@@ -139,7 +139,7 @@ struct FunctionSigInfo;
template <typename R, typename... ArgTypes> template <typename R, typename... ArgTypes>
struct FunctionSigInfo<R(ArgTypes...)> struct FunctionSigInfo<R(ArgTypes...)>
{ {
static VTKM_CONSTEXPR std::size_t Arity = sizeof...(ArgTypes); static constexpr std::size_t Arity = sizeof...(ArgTypes);
using ArityType = std::integral_constant<int, static_cast<int>(Arity)>; using ArityType = std::integral_constant<int, static_cast<int>(Arity)>;
using ResultType = R; using ResultType = R;
......
...@@ -80,35 +80,35 @@ struct ListContainsImpl; ...@@ -80,35 +80,35 @@ struct ListContainsImpl;
template <typename Type> template <typename Type>
struct ListContainsImpl<Type, brigand::empty_sequence> struct ListContainsImpl<Type, brigand::empty_sequence>
{ {
static VTKM_CONSTEXPR bool value = false; static constexpr bool value = false;
}; };
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
template <typename Type> template <typename Type>
struct ListContainsImpl<Type, brigand::list<vtkm::detail::UniversalTag>> struct ListContainsImpl<Type, brigand::list<vtkm::detail::UniversalTag>>
{ {
static VTKM_CONSTEXPR bool value = true; static constexpr bool value = true;
}; };
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
template <typename Type, typename T1> template <typename Type, typename T1>
struct ListContainsImpl<Type, brigand::list<T1>> struct ListContainsImpl<Type, brigand::list<T1>>
{ {
static VTKM_CONSTEXPR bool value = std::is_same<Type, T1>::value; static constexpr bool value = std::is_same<Type, T1>::value;
}; };
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
template <typename Type, typename T1, typename T2> template <typename Type, typename T1, typename T2>
struct ListContainsImpl<Type, brigand::list<T1, T2>> struct ListContainsImpl<Type, brigand::list<T1, T2>>
{ {
static VTKM_CONSTEXPR bool value = std::is_same<Type, T1>::value || std::is_same<Type, T2>::value; static constexpr bool value = std::is_same<Type, T1>::value || std::is_same<Type, T2>::value;
}; };
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
template <typename Type, typename T1, typename T2, typename T3> template <typename Type, typename T1, typename T2, typename T3>
struct ListContainsImpl<Type, brigand::list<T1, T2, T3>> struct ListContainsImpl<Type, brigand::list<T1, T2, T3>>
{ {
static VTKM_CONSTEXPR bool value = static constexpr bool value =
std::is_same<Type, T1>::value || std::is_same<Type, T2>::value || std::is_same<Type, T3>::value; std::is_same<Type, T1>::value || std::is_same<Type, T2>::value || std::is_same<Type, T3>::value;
}; };
...@@ -116,8 +116,8 @@ struct ListContainsImpl<Type, brigand::list<T1, T2, T3>> ...@@ -116,8 +116,8 @@ struct ListContainsImpl<Type, brigand::list<T1, T2, T3>>
template <typename Type, typename T1, typename T2, typename T3, typename T4> template <typename Type, typename T1, typename T2, typename T3, typename T4>
struct ListContainsImpl<Type, brigand::list<T1, T2, T3, T4>> struct ListContainsImpl<Type, brigand::list<T1, T2, T3, T4>>
{ {
static VTKM_CONSTEXPR bool value = std::is_same<Type, T1>::value || static constexpr bool value = std::is_same<Type, T1>::value || std::is_same<Type, T2>::value ||
std::is_same<Type, T2>::value || std::is_same<Type, T3>::value || std::is_same<Type, T4>::value; std::is_same<Type, T3>::value || std::is_same<Type, T4>::value;
}; };
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
...@@ -126,7 +126,7 @@ struct ListContainsImpl ...@@ -126,7 +126,7 @@ struct ListContainsImpl
{ {
using find_result = brigand::find<List, std::is_same<brigand::_1, Type>>; using find_result = brigand::find<List, std::is_same<brigand::_1, Type>>;
using size = brigand::size<find_result>; using size = brigand::size<find_result>;
static VTKM_CONSTEXPR bool value = (size::value != 0); static constexpr bool value = (size::value != 0);
}; };
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
...@@ -213,30 +213,7 @@ VTKM_CONT void ListForEachImpl(Functor&& f, ...@@ -213,30 +213,7 @@ VTKM_CONT void ListForEachImpl(Functor&& f,
template <typename R1, typename R2> template <typename R1, typename R2>
struct ListCrossProductImpl struct ListCrossProductImpl
{ {
#if defined(VTKM_MSVC) && _MSC_VER == 1800 // This is a lazy Cartesian product generator.
// This is a Cartesian product generator that is used
// when building with visual studio 2013. Visual Studio
// 2013 is unable to handle the lazy version as it can't
// deduce the correct template parameters
using type = brigand::reverse_fold<
brigand::list<R1, R2>,
brigand::list<brigand::list<>>,
brigand::bind<
brigand::join,
brigand::bind<
brigand::transform,
brigand::_2,
brigand::defer<brigand::bind<
brigand::join,
brigand::bind<
brigand::transform,
brigand::parent<brigand::_1>,
brigand::defer<brigand::bind<
brigand::list,
brigand::bind<brigand::push_front, brigand::_1, brigand::parent<brigand::_1>>>>>>>>>>;
#else
// This is a lazy Cartesian product generator that is used
// when using any compiler other than visual studio 2013.
// This version was settled on as being the best default // This version was settled on as being the best default
// version as all compilers including Intel handle this // version as all compilers including Intel handle this
// implementation without issue for very large cross products // implementation without issue for very large cross products
...@@ -250,7 +227,6 @@ struct ListCrossProductImpl ...@@ -250,7 +227,6 @@ struct ListCrossProductImpl
brigand::defer<brigand::bind< brigand::defer<brigand::bind<
brigand::list, brigand::list,
brigand::lazy::push_front<brigand::_1, brigand::parent<brigand::_1>>>>>>>>>>; brigand::lazy::push_front<brigand::_1, brigand::parent<brigand::_1>>>>>>>>>>;
#endif
}; };
......
...@@ -14,8 +14,6 @@ ...@@ -14,8 +14,6 @@
#define BRIGAND_COMP_MSVC #define BRIGAND_COMP_MSVC
#if _MSC_VER == 1900 #if _MSC_VER == 1900
#define BRIGAND_COMP_MSVC_2015 #define BRIGAND_COMP_MSVC_2015
#elif _MSC_VER == 1800
#define BRIGAND_COMP_MSVC_2013
#endif #endif
#elif __INTEL_COMPILER #elif __INTEL_COMPILER
#define BRIGAND_COMP_INTEL #define BRIGAND_COMP_INTEL
...@@ -902,7 +900,7 @@ namespace detail ...@@ -902,7 +900,7 @@ namespace detail
#include <initializer_list> #include <initializer_list>
namespace brigand namespace brigand
{ {
#if defined(BRIGAND_COMP_MSVC_2013) || defined(BRIGAND_COMP_CUDA) || defined(BRIGAND_COMP_INTEL) #if defined(BRIGAND_COMP_CUDA) || defined(BRIGAND_COMP_INTEL)
namespace detail namespace detail
{ {
template<class P, class T> template<class P, class T>
...@@ -961,7 +959,7 @@ namespace brigand ...@@ -961,7 +959,7 @@ namespace brigand
} }
namespace brigand namespace brigand
{ {
#if defined(BRIGAND_COMP_MSVC_2013) || defined(BRIGAND_COMP_CUDA) || defined(BRIGAND_COMP_INTEL) #if defined(BRIGAND_COMP_CUDA) || defined(BRIGAND_COMP_INTEL)