Address Alexander's comments

yubingex007-a11y · yubingex007-a11y · commit d32f5dac43a4 · 2021-04-21T16:05:54.000+08:00
diff --git a/sycl/include/CL/sycl/ONEAPI/matrix/matrix-amx.hpp b/sycl/include/CL/sycl/ONEAPI/matrix/matrix-amx.hpp
@@ -180,8 +180,8 @@ template <typename Group, typename T, size_t NumRows, size_t NumCols,
           matrix_layout Layout>
 struct joint_matrix<
     Group, T, NumRows, NumCols, Layout,
-    typename std::enable_if<(NumRows <= tile_size) &&
-                            (NumCols * sizeof(T) / 4 <= tile_size)>::type> {
+    typename std::enable_if_t<(NumRows <= tile_size) &&
+                              (NumCols * sizeof(T) / 4 <= tile_size)>> {
 public:
   static constexpr size_t trows = (NumRows + tile_size - 1) / tile_size;
   // tcols: Num of tiles in column.
@@ -201,51 +201,51 @@ struct joint_matrix<
 
 namespace detail {
 
+using namespace experimental;
+
 template <typename Group, typename T, size_t NumRows, size_t NumCols,
-          experimental::matrix::matrix_layout Layout>
-inline __SYCL_ALWAYS_INLINE static typename std::enable_if<
-    (NumRows > experimental::matrix::tile_size) ||
-        (NumCols * sizeof(T) / 4 > experimental::matrix::tile_size),
-    void>::type
-submatrix_load(
-    detail::submatrix<T> &sub_m,
-    experimental::matrix::joint_matrix<Group, T, NumRows, NumCols, Layout> jm,
-    uint32_t row, uint32_t col, size_t stride,
-    experimental::matrix::matrix_layout layout, bool shouldreload) {
+          matrix::matrix_layout Layout>
+inline __SYCL_ALWAYS_INLINE static
+    typename std::enable_if_t<(NumRows > matrix::tile_size) ||
+                                  (NumCols * sizeof(T) / 4 > matrix::tile_size),
+                              void>
+    submatrix_load(detail::submatrix<T> &sub_m,
+                   matrix::joint_matrix<Group, T, NumRows, NumCols, Layout> jm,
+                   uint32_t row, uint32_t col, size_t stride,
+                   matrix::matrix_layout layout, bool shouldreload) {
   uint32_t offset = (row * stride + col);
   T *ptr = reinterpret_cast<T *>(jm.raw_storage);
   ptr += offset;
   stride *= sizeof(T);
-  sub_m.rows = experimental::matrix::tile_size;
-  sub_m.cols = experimental::matrix::tile_size * 4;
-  sub_m.tile = experimental::matrix::tileloadd64_internal(
+  sub_m.rows = matrix::tile_size;
+  sub_m.cols = matrix::tile_size * 4;
+  sub_m.tile = matrix::tileloadd64_internal(
       sub_m.rows, sub_m.cols, reinterpret_cast<char *>(ptr), stride);
 }
 
 template <typename Group, typename T, size_t NumRows, size_t NumCols,
-          experimental::matrix::matrix_layout Layout>
-inline __SYCL_ALWAYS_INLINE static typename std::enable_if<
-    (NumRows <= experimental::matrix::tile_size) &&
-        (NumCols * sizeof(T) / 4 <= experimental::matrix::tile_size),
-    void>::type
-submatrix_load(
-    detail::submatrix<T> &sub_m,
-    experimental::matrix::joint_matrix<Group, T, NumRows, NumCols, Layout> &jm,
-    uint32_t row, uint32_t col, size_t stride,
-    experimental::matrix::matrix_layout layout, bool shouldreload) {
+          matrix::matrix_layout Layout>
+inline __SYCL_ALWAYS_INLINE static
+    typename std::enable_if_t<(NumRows <= matrix::tile_size) &&
+                                  (NumCols * sizeof(T) / 4 <=
+                                   matrix::tile_size),
+                              void>
+    submatrix_load(detail::submatrix<T> &sub_m,
+                   matrix::joint_matrix<Group, T, NumRows, NumCols, Layout> &jm,
+                   uint32_t row, uint32_t col, size_t stride,
+                   matrix::matrix_layout layout, bool shouldreload) {
   if (shouldreload) {
-    // Force sub_m.tile's shape to be experimental::matrix::tile_size *
-    // experimental::matrix::tile_size * 4
-    int8_t NewjmC[experimental::matrix::tile_size *
-                  experimental::matrix::tile_size * 4];
-    experimental::matrix::tilestored64_internal(
-        NumRows, NumCols * sizeof(T), reinterpret_cast<char *>(NewjmC),
-        experimental::matrix::tile_size * 4, jm.tile);
-    sub_m.rows = experimental::matrix::tile_size;
-    sub_m.cols = experimental::matrix::tile_size * 4;
-    sub_m.tile = experimental::matrix::tileloadd64_internal(
-        sub_m.rows, sub_m.cols, reinterpret_cast<char *>(NewjmC),
-        experimental::matrix::tile_size * 4);
+    // Force sub_m.tile's shape to be matrix::tile_size *
+    // matrix::tile_size * 4
+    int8_t NewjmC[matrix::tile_size * matrix::tile_size * 4];
+    matrix::tilestored64_internal(NumRows, NumCols * sizeof(T),
+                                  reinterpret_cast<char *>(NewjmC),
+                                  matrix::tile_size * 4, jm.tile);
+    sub_m.rows = matrix::tile_size;
+    sub_m.cols = matrix::tile_size * 4;
+    sub_m.tile = matrix::tileloadd64_internal(sub_m.rows, sub_m.cols,
+                                              reinterpret_cast<char *>(NewjmC),
+                                              matrix::tile_size * 4);
     return;
   }
   sub_m.rows = NumRows;
@@ -258,62 +258,56 @@ inline __SYCL_ALWAYS_INLINE static void
 submatrix_mad(detail::submatrix<int8_t> &sub_ma,
               detail::submatrix<int8_t> &sub_mb,
               detail::submatrix<int32_t> &sub_mc) {
-  sub_mc.tile = experimental::matrix::tdpbssd_internal(
-      sub_mc.rows, sub_mc.cols, sub_ma.cols, sub_mc.tile, sub_ma.tile,
-      sub_mb.tile);
+  sub_mc.tile = matrix::tdpbssd_internal(sub_mc.rows, sub_mc.cols, sub_ma.cols,
+                                         sub_mc.tile, sub_ma.tile, sub_mb.tile);
 }
 
 // This handles cases where T1 is int16(bfloat16), T2 is float.
 inline __SYCL_ALWAYS_INLINE static void
 submatrix_mad(detail::submatrix<unsigned short> &sub_ma,
               detail::submatrix<unsigned short> &sub_mb,
               detail::submatrix<float> &sub_mc) {
-  sub_mc.tile = experimental::matrix::tdpbf16ps_internal(
-      sub_mc.rows, sub_mc.cols, sub_ma.cols, sub_mc.tile, sub_ma.tile,
-      sub_mb.tile);
+  sub_mc.tile =
+      matrix::tdpbf16ps_internal(sub_mc.rows, sub_mc.cols, sub_ma.cols,
+                                 sub_mc.tile, sub_ma.tile, sub_mb.tile);
 }
 
 template <typename Group, typename T, size_t NumRows, size_t NumCols>
 inline __SYCL_ALWAYS_INLINE static
-    typename std::enable_if<(NumRows > experimental::matrix::tile_size) ||
-                                (NumCols * sizeof(T) / 4 >
-                                 experimental::matrix::tile_size),
-                            void>::type
-    submatrix_store(
-        detail::submatrix<T> &sub_m,
-        experimental::matrix::joint_matrix<Group, T, NumRows, NumCols> &jm,
-        uint32_t row, uint32_t col, size_t stride,
-        experimental::matrix::matrix_layout layout, bool shouldreload) {
+    typename std::enable_if_t<(NumRows > matrix::tile_size) ||
+                                  (NumCols * sizeof(T) / 4 > matrix::tile_size),
+                              void>
+    submatrix_store(detail::submatrix<T> &sub_m,
+                    matrix::joint_matrix<Group, T, NumRows, NumCols> &jm,
+                    uint32_t row, uint32_t col, size_t stride,
+                    matrix::matrix_layout layout, bool shouldreload) {
   uint32_t offset = (row * stride + col);
   T *ptr = reinterpret_cast<T *>(jm.raw_storage);
   ptr += offset;
   stride *= sizeof(T);
-  experimental::matrix::tilestored64_internal(sub_m.rows, sub_m.cols,
-                                              reinterpret_cast<char *>(ptr),
-                                              stride, sub_m.tile);
+  matrix::tilestored64_internal(sub_m.rows, sub_m.cols,
+                                reinterpret_cast<char *>(ptr), stride,
+                                sub_m.tile);
 }
 
 template <typename Group, typename T, size_t NumRows, size_t NumCols>
 inline __SYCL_ALWAYS_INLINE static
-    typename std::enable_if<(NumRows <= experimental::matrix::tile_size) &&
-                                (NumCols * sizeof(T) / 4 <=
-                                 experimental::matrix::tile_size),
-                            void>::type
-    submatrix_store(
-        detail::submatrix<T> &sub_m,
-        experimental::matrix::joint_matrix<Group, T, NumRows, NumCols> &jm,
-        uint32_t row, uint32_t col, size_t stride,
-        experimental::matrix::matrix_layout layout, bool shouldreload) {
+    typename std::enable_if_t<(NumRows <= matrix::tile_size) &&
+                                  (NumCols * sizeof(T) / 4 <=
+                                   matrix::tile_size),
+                              void>
+    submatrix_store(detail::submatrix<T> &sub_m,
+                    matrix::joint_matrix<Group, T, NumRows, NumCols> &jm,
+                    uint32_t row, uint32_t col, size_t stride,
+                    matrix::matrix_layout layout, bool shouldreload) {
   if (shouldreload) {
-    int8_t NewjmC[experimental::matrix::tile_size *
-                  experimental::matrix::tile_size * 4];
-    experimental::matrix::tilestored64_internal(
-        experimental::matrix::tile_size, experimental::matrix::tile_size * 4,
-        reinterpret_cast<char *>(NewjmC), experimental::matrix::tile_size * 4,
-        sub_m.tile);
-    jm.tile = experimental::matrix::tileloadd64_internal(
-        NumRows, NumCols * sizeof(T), reinterpret_cast<char *>(NewjmC),
-        experimental::matrix::tile_size * 4);
+    int8_t NewjmC[matrix::tile_size * matrix::tile_size * 4];
+    matrix::tilestored64_internal(matrix::tile_size, matrix::tile_size * 4,
+                                  reinterpret_cast<char *>(NewjmC),
+                                  matrix::tile_size * 4, sub_m.tile);
+    jm.tile = matrix::tileloadd64_internal(NumRows, NumCols * sizeof(T),
+                                           reinterpret_cast<char *>(NewjmC),
+                                           matrix::tile_size * 4);
     return;
   }
   jm.tile = sub_m.tile;
@@ -326,8 +320,8 @@ namespace experimental::matrix {
 // This handles cases where matrix can't be accommodated by a tile
 template <typename Group, typename T, size_t NumRows, size_t NumCols,
           matrix_layout Layout, access::address_space Space>
-inline __SYCL_ALWAYS_INLINE typename std::enable_if<
-    (NumRows > tile_size) || (NumCols * sizeof(T) / 4 > tile_size), void>::type
+inline __SYCL_ALWAYS_INLINE typename std::enable_if_t<
+    (NumRows > tile_size) || (NumCols * sizeof(T) / 4 > tile_size), void>
 joint_matrix_load(Group sg,
                   joint_matrix<Group, T, NumRows, NumCols, Layout> &jm,
                   multi_ptr<T, Space> src, size_t stride,
@@ -347,14 +341,12 @@ joint_matrix_load(Group sg,
 // This handles cases where matrix can be put into a tile
 template <typename Group, typename T, size_t NumRows, size_t NumCols,
           matrix_layout Layout, access::address_space Space>
-inline __SYCL_ALWAYS_INLINE
-    typename std::enable_if<(NumRows <= tile_size) &&
-                                (NumCols * sizeof(T) / 4 <= tile_size),
-                            void>::type
-    joint_matrix_load(Group sg,
-                      joint_matrix<Group, T, NumRows, NumCols, Layout> &jm,
-                      multi_ptr<T, Space> src, size_t stride,
-                      matrix_layout layout) {
+inline __SYCL_ALWAYS_INLINE typename std::enable_if_t<
+    (NumRows <= tile_size) && (NumCols * sizeof(T) / 4 <= tile_size), void>
+joint_matrix_load(Group sg,
+                  joint_matrix<Group, T, NumRows, NumCols, Layout> &jm,
+                  multi_ptr<T, Space> src, size_t stride,
+                  matrix_layout layout) {
   T *mem = src.get();
   // tileload happens!
   jm.tile =
@@ -366,8 +358,8 @@ inline __SYCL_ALWAYS_INLINE
 // This handles cases where matrix can't be accommodated by a tile
 template <typename Group, typename T, size_t NumRows, size_t NumCols,
           matrix_layout Layout, access::address_space Space>
-inline __SYCL_ALWAYS_INLINE typename std::enable_if<
-    (NumRows > tile_size) || (NumCols * sizeof(T) / 4 > tile_size), void>::type
+inline __SYCL_ALWAYS_INLINE typename std::enable_if_t<
+    (NumRows > tile_size) || (NumCols * sizeof(T) / 4 > tile_size), void>
 joint_matrix_store(Group sg,
                    joint_matrix<Group, T, NumRows, NumCols, Layout> &jm,
                    multi_ptr<T, Space> dst, size_t stride,
@@ -387,9 +379,9 @@ joint_matrix_store(Group sg,
 template <typename Group, typename T, size_t NumRows, size_t NumCols,
           matrix_layout Layout, access::address_space Space>
 inline __SYCL_ALWAYS_INLINE
-    typename std::enable_if<(NumRows <= tile_size) &&
-                                (NumCols * sizeof(T) / 4 <= tile_size),
-                            void>::type
+    typename std::enable_if_t<(NumRows <= tile_size) &&
+                                  (NumCols * sizeof(T) / 4 <= tile_size),
+                              void>::type
     joint_matrix_store(Group sg,
                        joint_matrix<Group, T, NumRows, NumCols, Layout> &jm,
                        multi_ptr<T, Space> dst, size_t stride,
@@ -406,14 +398,14 @@ template <typename Group, typename T1, typename T2, size_t NumRowsA,
           size_t NumColsA, size_t NumRowsB, size_t NumColsB, size_t NumRowsC,
           size_t NumColsC, matrix_layout LayoutA, matrix_layout LayoutB,
           matrix_layout LayoutC>
-inline __SYCL_ALWAYS_INLINE typename std::enable_if<
+inline __SYCL_ALWAYS_INLINE typename std::enable_if_t<
     ((std::is_same<T1, int8_t>::value && std::is_same<T2, int32_t>::value) ||
      (std::is_same<T1, unsigned short>::value &&
       std::is_same<T2, float>::value)) &&
         (LayoutA == matrix_layout::row_major) &&
         (LayoutB == matrix_layout::packed_b) &&
         (LayoutC == matrix_layout::row_major),
-    void>::type
+    void>
 joint_matrix_mad(Group sg,
                  joint_matrix<Group, T1, NumRowsA, NumColsA, LayoutA> &jmA,
                  joint_matrix<Group, T1, NumRowsB, NumColsB, LayoutB> &jmB,
