[SYCL][NFC] Fix use of common macro names in type_list.hpp and common.hpp (#6493)

This commit renames a number of template parameters in the DPC++ headers
to reduce chance of conflicts with user-defined macros. Most notable
of these renamings are VL, DIM and NDIMS.

Signed-off-by: Larsen, Steffen <[email protected]>

Author: steffenlarsen

sycl/include/sycl/detail/common.hpp

@@ -244,33 +244,33 @@ template <template <int> class T> struct InitializedVal<3, T> {
 };
 
 /// Helper class for the \c NDLoop.
-template <int NDIMS, int DIM, template <int> class LoopBoundTy, typename FuncTy,
+template <int NDims, int Dim, template <int> class LoopBoundTy, typename FuncTy,
           template <int> class LoopIndexTy>
 struct NDLoopIterateImpl {
-  NDLoopIterateImpl(const LoopIndexTy<NDIMS> &LowerBound,
-                    const LoopBoundTy<NDIMS> &Stride,
-                    const LoopBoundTy<NDIMS> &UpperBound, FuncTy f,
-                    LoopIndexTy<NDIMS> &Index) {
-    constexpr size_t AdjIdx = NDIMS - 1 - DIM;
+  NDLoopIterateImpl(const LoopIndexTy<NDims> &LowerBound,
+                    const LoopBoundTy<NDims> &Stride,
+                    const LoopBoundTy<NDims> &UpperBound, FuncTy f,
+                    LoopIndexTy<NDims> &Index) {
+    constexpr size_t AdjIdx = NDims - 1 - Dim;
     for (Index[AdjIdx] = LowerBound[AdjIdx]; Index[AdjIdx] < UpperBound[AdjIdx];
          Index[AdjIdx] += Stride[AdjIdx]) {
 
-      NDLoopIterateImpl<NDIMS, DIM - 1, LoopBoundTy, FuncTy, LoopIndexTy>{
+      NDLoopIterateImpl<NDims, Dim - 1, LoopBoundTy, FuncTy, LoopIndexTy>{
           LowerBound, Stride, UpperBound, f, Index};
     }
   }
 };
 
-// Specialization for DIM=0 to terminate recursion
-template <int NDIMS, template <int> class LoopBoundTy, typename FuncTy,
+// Specialization for Dim=0 to terminate recursion
+template <int NDims, template <int> class LoopBoundTy, typename FuncTy,
           template <int> class LoopIndexTy>
-struct NDLoopIterateImpl<NDIMS, 0, LoopBoundTy, FuncTy, LoopIndexTy> {
-  NDLoopIterateImpl(const LoopIndexTy<NDIMS> &LowerBound,
-                    const LoopBoundTy<NDIMS> &Stride,
-                    const LoopBoundTy<NDIMS> &UpperBound, FuncTy f,
-                    LoopIndexTy<NDIMS> &Index) {
+struct NDLoopIterateImpl<NDims, 0, LoopBoundTy, FuncTy, LoopIndexTy> {
+  NDLoopIterateImpl(const LoopIndexTy<NDims> &LowerBound,
+                    const LoopBoundTy<NDims> &Stride,
+                    const LoopBoundTy<NDims> &UpperBound, FuncTy f,
+                    LoopIndexTy<NDims> &Index) {
 
-    constexpr size_t AdjIdx = NDIMS - 1;
+    constexpr size_t AdjIdx = NDims - 1;
     for (Index[AdjIdx] = LowerBound[AdjIdx]; Index[AdjIdx] < UpperBound[AdjIdx];
          Index[AdjIdx] += Stride[AdjIdx]) {
 
@@ -279,43 +279,43 @@ struct NDLoopIterateImpl<NDIMS, 0, LoopBoundTy, FuncTy, LoopIndexTy> {
   }
 };
 
-/// Generates an NDIMS-dimensional perfect loop nest. The purpose of this class
+/// Generates an NDims-dimensional perfect loop nest. The purpose of this class
 /// is to better support handling of situations where there must be a loop nest
 /// over a multi-dimensional space - it allows to avoid generating unnecessary
 /// outer loops like 'for (int z=0; z<1; z++)' in case of 1D and 2D iteration
 /// spaces or writing specializations of the algorithms for 1D, 2D and 3D cases.
 /// Loop is unrolled in a reverse directions, i.e. ID = 0 is the inner-most one.
-template <int NDIMS> struct NDLoop {
+template <int NDims> struct NDLoop {
   /// Generates ND loop nest with {0,..0} .. \c UpperBound bounds with unit
   /// stride. Applies \c f at each iteration, passing current index of
-  /// \c LoopIndexTy<NDIMS> type as the parameter.
+  /// \c LoopIndexTy<NDims> type as the parameter.
   template <template <int> class LoopBoundTy, typename FuncTy,
             template <int> class LoopIndexTy = LoopBoundTy>
-  static __SYCL_ALWAYS_INLINE void iterate(const LoopBoundTy<NDIMS> &UpperBound,
+  static __SYCL_ALWAYS_INLINE void iterate(const LoopBoundTy<NDims> &UpperBound,
                                            FuncTy f) {
-    const LoopIndexTy<NDIMS> LowerBound =
-        InitializedVal<NDIMS, LoopIndexTy>::template get<0>();
-    const LoopBoundTy<NDIMS> Stride =
-        InitializedVal<NDIMS, LoopBoundTy>::template get<1>();
-    LoopIndexTy<NDIMS> Index =
-        InitializedVal<NDIMS, LoopIndexTy>::template get<0>();
-
-    NDLoopIterateImpl<NDIMS, NDIMS - 1, LoopBoundTy, FuncTy, LoopIndexTy>{
+    const LoopIndexTy<NDims> LowerBound =
+        InitializedVal<NDims, LoopIndexTy>::template get<0>();
+    const LoopBoundTy<NDims> Stride =
+        InitializedVal<NDims, LoopBoundTy>::template get<1>();
+    LoopIndexTy<NDims> Index =
+        InitializedVal<NDims, LoopIndexTy>::template get<0>();
+
+    NDLoopIterateImpl<NDims, NDims - 1, LoopBoundTy, FuncTy, LoopIndexTy>{
         LowerBound, Stride, UpperBound, f, Index};
   }
 
   /// Generates ND loop nest with \c LowerBound .. \c UpperBound bounds and
   /// stride \c Stride. Applies \c f at each iteration, passing current index of
-  /// \c LoopIndexTy<NDIMS> type as the parameter.
+  /// \c LoopIndexTy<NDims> type as the parameter.
   template <template <int> class LoopBoundTy, typename FuncTy,
             template <int> class LoopIndexTy = LoopBoundTy>
-  static __SYCL_ALWAYS_INLINE void iterate(const LoopIndexTy<NDIMS> &LowerBound,
-                                           const LoopBoundTy<NDIMS> &Stride,
-                                           const LoopBoundTy<NDIMS> &UpperBound,
+  static __SYCL_ALWAYS_INLINE void iterate(const LoopIndexTy<NDims> &LowerBound,
+                                           const LoopBoundTy<NDims> &Stride,
+                                           const LoopBoundTy<NDims> &UpperBound,
                                            FuncTy f) {
-    LoopIndexTy<NDIMS> Index =
-        InitializedVal<NDIMS, LoopIndexTy>::template get<0>();
-    NDLoopIterateImpl<NDIMS, NDIMS - 1, LoopBoundTy, FuncTy, LoopIndexTy>{
+    LoopIndexTy<NDims> Index =
+        InitializedVal<NDims, LoopIndexTy>::template get<0>();
+    NDLoopIterateImpl<NDims, NDims - 1, LoopBoundTy, FuncTy, LoopIndexTy>{
         LowerBound, Stride, UpperBound, f, Index};
   }
 };

sycl/include/sycl/detail/type_list.hpp

@@ -31,58 +31,59 @@ struct is_empty_type_list
 
 template <> struct type_list<> {};
 
-template <typename H, typename... T> struct type_list<H, T...> {
-  using head = H;
-  using tail = type_list<T...>;
+template <typename Head, typename... Tail> struct type_list<Head, Tail...> {
+  using head = Head;
+  using tail = type_list<Tail...>;
 };
 
-template <typename H, typename... T, typename... T2>
-struct type_list<type_list<H, T...>, T2...> {
+template <typename Head, typename... Tail, typename... Tail2>
+struct type_list<type_list<Head, Tail...>, Tail2...> {
 private:
-  using remainder = tail_t<type_list<H>>;
+  using remainder = tail_t<type_list<Head>>;
   static constexpr bool has_remainder = !is_empty_type_list<remainder>::value;
-  using without_remainder = type_list<T..., T2...>;
-  using with_remainder = type_list<remainder, T..., T2...>;
+  using without_remainder = type_list<Tail..., Tail2...>;
+  using with_remainder = type_list<remainder, Tail..., Tail2...>;
 
 public:
-  using head = head_t<type_list<H>>;
+  using head = head_t<type_list<Head>>;
   using tail = conditional_t<has_remainder, with_remainder, without_remainder>;
 };
 
 // is_contained
-template <typename T, typename L>
+template <typename T, typename TypeList>
 struct is_contained
-    : conditional_t<std::is_same<remove_cv_t<T>, head_t<L>>::value,
-                    std::true_type, is_contained<T, tail_t<L>>> {};
+    : conditional_t<std::is_same<remove_cv_t<T>, head_t<TypeList>>::value,
+                    std::true_type, is_contained<T, tail_t<TypeList>>> {};
 
 template <typename T>
 struct is_contained<T, empty_type_list> : std::false_type {};
 
 // value_list
-template <typename T, T... V> struct value_list;
+template <typename T, T... Values> struct value_list;
 
-template <typename T, T H, T... V> struct value_list<T, H, V...> {
-  static constexpr T head = H;
-  using tail = value_list<T, V...>;
+template <typename T, T Head, T... Tail> struct value_list<T, Head, Tail...> {
+  static constexpr T head = Head;
+  using tail = value_list<T, Tail...>;
 };
 
 template <typename T> struct value_list<T> {};
 
 // is_contained_value
-template <typename T, T V, typename TL>
+template <typename T, T Value, typename ValueList>
 struct is_contained_value
-    : conditional_t<V == TL::head, std::true_type,
-                    is_contained_value<T, V, tail_t<TL>>> {};
+    : conditional_t<Value == ValueList::head, std::true_type,
+                    is_contained_value<T, Value, tail_t<ValueList>>> {};
 
-template <typename T, T V>
-struct is_contained_value<T, V, value_list<T>> : std::false_type {};
+template <typename T, T Value>
+struct is_contained_value<T, Value, value_list<T>> : std::false_type {};
 
 //  address_space_list
-template <access::address_space... V>
-using address_space_list = value_list<access::address_space, V...>;
+template <access::address_space... Values>
+using address_space_list = value_list<access::address_space, Values...>;
 
-template <access::address_space AS, typename VL>
-using is_one_of_spaces = is_contained_value<access::address_space, AS, VL>;
+template <access::address_space AddressSpace, typename ValueList>
+using is_one_of_spaces =
+    is_contained_value<access::address_space, AddressSpace, ValueList>;
 
 // size type predicates
 template <typename T1, typename T2>
@@ -103,35 +104,39 @@ struct is_type_size_half_of : bool_constant<(sizeof(T1) == (sizeof(T2) / 2))> {
 };
 
 // find required type
-template <typename TL, template <typename, typename> class C, typename T>
+template <typename TypeList, template <typename, typename> class Comp,
+          typename T>
 struct find_type {
-  using head = head_t<TL>;
-  using tail = typename find_type<tail_t<TL>, C, T>::type;
-  using type = conditional_t<C<head, T>::value, head, tail>;
+  using head = head_t<TypeList>;
+  using tail = typename find_type<tail_t<TypeList>, Comp, T>::type;
+  using type = conditional_t<Comp<head, T>::value, head, tail>;
 };
 
-template <template <typename, typename> class C, typename T>
-struct find_type<empty_type_list, C, T> {
+template <template <typename, typename> class Comp, typename T>
+struct find_type<empty_type_list, Comp, T> {
   using type = void;
 };
 
-template <typename TL, template <typename, typename> class C, typename T>
-using find_type_t = typename find_type<TL, C, T>::type;
+template <typename TypeList, template <typename, typename> class Comp,
+          typename T>
+using find_type_t = typename find_type<TypeList, Comp, T>::type;
 
-template <typename TL, typename T>
-using find_same_size_type_t = find_type_t<TL, is_type_size_equal, T>;
+template <typename TypeList, typename T>
+using find_same_size_type_t = find_type_t<TypeList, is_type_size_equal, T>;
 
-template <typename TL, typename T>
-using find_smaller_type_t = find_type_t<TL, is_type_size_less, T>;
+template <typename TypeList, typename T>
+using find_smaller_type_t = find_type_t<TypeList, is_type_size_less, T>;
 
-template <typename TL, typename T>
-using find_larger_type_t = find_type_t<TL, is_type_size_greater, T>;
+template <typename TypeList, typename T>
+using find_larger_type_t = find_type_t<TypeList, is_type_size_greater, T>;
 
-template <typename TL, typename T>
-using find_twice_as_small_type_t = find_type_t<TL, is_type_size_half_of, T>;
+template <typename TypeList, typename T>
+using find_twice_as_small_type_t =
+    find_type_t<TypeList, is_type_size_half_of, T>;
 
-template <typename TL, typename T>
-using find_twice_as_large_type_t = find_type_t<TL, is_type_size_double_of, T>;
+template <typename TypeList, typename T>
+using find_twice_as_large_type_t =
+    find_type_t<TypeList, is_type_size_double_of, T>;
 
 } // namespace detail
 } // namespace sycl

sycl/test/regression/check_simple_name_collisions.cpp

@@ -20,6 +20,10 @@
 #define BUFFER
 #define IMAGE 
 #define UNDEFINED
+#define VL
+#define DIM
+#define DIMS
+#define NDIMS
 
 #include <sycl/sycl.hpp>