Save SLM chunks into registers prior to summing over delta_m, delta_n

This does not make any difference in performance due to compiler
optimization being effective as loops are unrolled, but makes compiler's
job easier and the intent clearer.

Author: oleksandr-pavlyk

dpctl/tensor/libtensor/include/kernels/linalg_functions/gemm.hpp

@@ -970,6 +970,7 @@ class GemmBatchFunctorThreadNM_vecm
         size_t i = block_i * wg_delta_n * wi_delta_n;
         size_t j = block_j * wg_delta_m * wi_total_delta_m;
 
+        using slmA_t = typename LocAccT1::value_type;
         using slmB_t = typename LocAccT2::value_type;
 
         const size_t a_st0 = k;
@@ -1037,8 +1038,7 @@ class GemmBatchFunctorThreadNM_vecm
                     slmB_t vec{};
 #pragma unroll
                     for (std::uint32_t lane_id = 0; lane_id < m_vec_size;
-                         ++lane_id)
-                    {
+                         ++lane_id) {
                         const size_t g_j1 = g_j + lane_id;
                         vec[lane_id] = (g_j1 < m && g_s < k)
                                            ? static_cast<resT>(
@@ -1057,16 +1057,29 @@ class GemmBatchFunctorThreadNM_vecm
             const std::uint32_t lo_lhs_st_k = (wg_delta_n * wi_delta_n);
             const std::uint32_t lo_rhs_rk_k = (wg_delta_m * wi_delta_m_vecs);
             for (std::uint32_t pr_k = 0; pr_k < wi_delta_k; ++pr_k) {
+                std::array<slmA_t, wi_delta_n> pr_lhs{};
+#pragma unroll
+                for (std::uint32_t pr_i = 0; pr_i < wi_delta_n; ++pr_i) {
+                    pr_lhs[pr_i] =
+                        local_lhs_block[pr_k * lo_lhs_st_k +
+                                        (local_i + pr_i * wg_delta_n)];
+                }
+
+                std::array<slmB_t, wi_delta_m_vecs> pr_rhs{};
+#pragma unroll
+                for (std::uint32_t pr_j = 0; pr_j < wi_delta_m_vecs; ++pr_j) {
+                    pr_rhs[pr_j] =
+                        local_rhs_block[pr_k * lo_rhs_rk_k +
+                                        (local_j + pr_j * wg_delta_m)];
+                }
+
 #pragma unroll
                 for (std::uint32_t pr_i = 0; pr_i < wi_delta_n; ++pr_i) {
 #pragma unroll
                     for (std::uint32_t pr_j = 0; pr_j < wi_delta_m_vecs; ++pr_j)
                     {
                         private_C[pr_i * wi_delta_m_vecs + pr_j] +=
-                            local_lhs_block[pr_k * lo_lhs_st_k +
-                                            (local_i + pr_i * wg_delta_n)] *
-                            local_rhs_block[pr_k * lo_rhs_rk_k +
-                                            (local_j + pr_j * wg_delta_m)];
+                            pr_lhs[pr_i] * pr_rhs[pr_j];
                     }
                 }
             }
@@ -1106,8 +1119,7 @@ class GemmBatchFunctorThreadNM_vecm
                             j + (local_j + pr_j * wg_delta_m) * m_vec_size;
 #pragma unroll
                         for (std::uint32_t lane_id = 0; lane_id < m_vec_size;
-                             ++lane_id)
-                        {
+                             ++lane_id) {
                             const size_t out_flat_id =
                                 out_i * c_st0 + (out_j + lane_id) * c_st1;
                             if (out_j + lane_id < m) {