[SYCL] Fix marray aliases (#8272)

SYCL 2020 introduced the marray type with a number of aliases for fixed
sizes and types. In the DPC++ device headers these are not using the
types specified by the specification. This commit fixes the types in the
aliases.

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

Author: steffenlarsen

sycl/include/sycl/marray.hpp

@@ -392,22 +392,27 @@ template <typename Type, std::size_t NumElements> class marray {
   using ALIAS##N = sycl::marray<TYPE, N>;
 
 #define __SYCL_MAKE_MARRAY_ALIASES_FOR_ARITHMETIC_TYPES(N)                     \
-  __SYCL_MAKE_MARRAY_ALIAS(mchar, char, N)                                     \
-  __SYCL_MAKE_MARRAY_ALIAS(mshort, short, N)                                   \
-  __SYCL_MAKE_MARRAY_ALIAS(mint, int, N)                                       \
-  __SYCL_MAKE_MARRAY_ALIAS(mlong, long, N)                                     \
+  __SYCL_MAKE_MARRAY_ALIAS(mbool, bool, N)                                     \
+  __SYCL_MAKE_MARRAY_ALIAS(mchar, std::int8_t, N)                              \
+  __SYCL_MAKE_MARRAY_ALIAS(mshort, std::int16_t, N)                            \
+  __SYCL_MAKE_MARRAY_ALIAS(mint, std::int32_t, N)                              \
+  __SYCL_MAKE_MARRAY_ALIAS(mlong, std::int64_t, N)                             \
+  __SYCL_MAKE_MARRAY_ALIAS(mlonglong, std::int64_t, N)                         \
   __SYCL_MAKE_MARRAY_ALIAS(mfloat, float, N)                                   \
   __SYCL_MAKE_MARRAY_ALIAS(mdouble, double, N)                                 \
   __SYCL_MAKE_MARRAY_ALIAS(mhalf, half, N)
 
+// FIXME: schar, longlong and ulonglong aliases are not defined by SYCL 2020
+//        spec, but they are preserved in SYCL 2020 mode, because SYCL-CTS is
+//        still using them.
+//        See KhronosGroup/SYCL-CTS#446 and KhronosGroup/SYCL-Docs#335
 #define __SYCL_MAKE_MARRAY_ALIASES_FOR_SIGNED_AND_UNSIGNED_TYPES(N)            \
-  __SYCL_MAKE_MARRAY_ALIAS(mschar, signed char, N)                             \
-  __SYCL_MAKE_MARRAY_ALIAS(muchar, unsigned char, N)                           \
-  __SYCL_MAKE_MARRAY_ALIAS(mushort, unsigned short, N)                         \
-  __SYCL_MAKE_MARRAY_ALIAS(muint, unsigned int, N)                             \
-  __SYCL_MAKE_MARRAY_ALIAS(mulong, unsigned long, N)                           \
-  __SYCL_MAKE_MARRAY_ALIAS(mlonglong, long long, N)                            \
-  __SYCL_MAKE_MARRAY_ALIAS(mulonglong, unsigned long long, N)
+  __SYCL_MAKE_MARRAY_ALIAS(mschar, std::int8_t, N)                             \
+  __SYCL_MAKE_MARRAY_ALIAS(muchar, std::uint8_t, N)                            \
+  __SYCL_MAKE_MARRAY_ALIAS(mushort, std::uint16_t, N)                          \
+  __SYCL_MAKE_MARRAY_ALIAS(muint, std::uint32_t, N)                            \
+  __SYCL_MAKE_MARRAY_ALIAS(mulong, std::uint64_t, N)                           \
+  __SYCL_MAKE_MARRAY_ALIAS(mulonglong, std::uint64_t, N)
 
 #define __SYCL_MAKE_MARRAY_ALIASES_FOR_MARRAY_LENGTH(N)                        \
   __SYCL_MAKE_MARRAY_ALIASES_FOR_ARITHMETIC_TYPES(N)                           \

sycl/test/basic_tests/marray/marray.cpp

@@ -12,6 +12,17 @@
 #include <sycl/sycl.hpp>
 using namespace sycl;
 
+#define CHECK_ALIAS_BY_SIZE(ALIAS_MTYPE, ELEM_TYPE, MARRAY_SIZE)               \
+  static_assert(std::is_same_v<sycl::marray<ELEM_TYPE, MARRAY_SIZE>,           \
+                               sycl::ALIAS_MTYPE##MARRAY_SIZE>);
+
+#define CHECK_ALIAS(ALIAS_MTYPE, ELEM_TYPE)                                    \
+  CHECK_ALIAS_BY_SIZE(ALIAS_MTYPE, ELEM_TYPE, 2)                               \
+  CHECK_ALIAS_BY_SIZE(ALIAS_MTYPE, ELEM_TYPE, 3)                               \
+  CHECK_ALIAS_BY_SIZE(ALIAS_MTYPE, ELEM_TYPE, 4)                               \
+  CHECK_ALIAS_BY_SIZE(ALIAS_MTYPE, ELEM_TYPE, 8)                               \
+  CHECK_ALIAS_BY_SIZE(ALIAS_MTYPE, ELEM_TYPE, 16)
+
 struct NotDefaultConstructible {
   NotDefaultConstructible() = delete;
   constexpr NotDefaultConstructible(int){};
@@ -60,18 +71,22 @@ int main() {
   assert(static_cast<float>(b_marray[2]) == static_cast<float>(0.5));
   assert(static_cast<float>(b_marray[3]) == static_cast<float>(0.5));
 
-  // Check that [u]long[n] type aliases match marray<[unsigned] long, n> types.
-  assert((std::is_same<sycl::marray<long, 2>, sycl::mlong2>::value));
-  assert((std::is_same<sycl::marray<long, 3>, sycl::mlong3>::value));
-  assert((std::is_same<sycl::marray<long, 4>, sycl::mlong4>::value));
-  assert((std::is_same<sycl::marray<long, 8>, sycl::mlong8>::value));
-  assert((std::is_same<sycl::marray<long, 16>, sycl::mlong16>::value));
-  assert((std::is_same<sycl::marray<unsigned long, 2>, sycl::mulong2>::value));
-  assert((std::is_same<sycl::marray<unsigned long, 3>, sycl::mulong3>::value));
-  assert((std::is_same<sycl::marray<unsigned long, 4>, sycl::mulong4>::value));
-  assert((std::is_same<sycl::marray<unsigned long, 8>, sycl::mulong8>::value));
-  assert(
-      (std::is_same<sycl::marray<unsigned long, 16>, sycl::mulong16>::value));
+  // Check alias types.
+  CHECK_ALIAS(mbool, bool)
+  CHECK_ALIAS(mchar, std::int8_t)
+  CHECK_ALIAS(mschar, std::int8_t)
+  CHECK_ALIAS(muchar, std::uint8_t)
+  CHECK_ALIAS(mshort, std::int16_t)
+  CHECK_ALIAS(mushort, std::uint16_t)
+  CHECK_ALIAS(mint, std::int32_t)
+  CHECK_ALIAS(muint, std::uint32_t)
+  CHECK_ALIAS(mlong, std::int64_t)
+  CHECK_ALIAS(mulong, std::uint64_t)
+  CHECK_ALIAS(mlonglong, std::int64_t)
+  CHECK_ALIAS(mulonglong, std::uint64_t)
+  CHECK_ALIAS(mhalf, sycl::half)
+  CHECK_ALIAS(mfloat, float)
+  CHECK_ALIAS(mdouble, double)
 
   mint3 t000;
   mint3 t222{2};