Stylistic changes in accumulators.hpp

Use explicit type instead of auto for readability, save
common sub-expression to a temporary variable.

Move std::array variable declaration closer to its first use.

Author: oleksandr-pavlyk

dpctl/tensor/libtensor/include/kernels/accumulators.hpp

@@ -215,16 +215,17 @@ inclusive_scan_base_step(sycl::queue &exec_q,
             const size_t gid = it.get_global_id(0);
             const size_t lid = it.get_local_id(0);
 
-            const size_t iter_gid = gid / (acc_groups * wg_size);
-            const size_t chunk_gid = gid - (iter_gid * acc_groups * wg_size);
+            const size_t reduce_chunks = acc_groups * wg_size;
+            const size_t iter_gid = gid / reduce_chunks;
+            const size_t chunk_gid = gid - (iter_gid * reduce_chunks);
 
-            std::array<outputT, n_wi> local_iscan;
-
-            size_t i = chunk_gid * n_wi;
+            const size_t i = chunk_gid * n_wi;
             const auto &iter_offsets = iter_indexer(iter_gid);
             const auto &inp_iter_offset = iter_offsets.get_first_offset();
             const auto &out_iter_offset = iter_offsets.get_second_offset();
 
+            std::array<outputT, n_wi> local_iscan;
+
 #pragma unroll
             for (nwiT m_wi = 0; m_wi < n_wi; ++m_wi) {
                 const size_t i_m_wi = i + m_wi;
@@ -324,7 +325,7 @@ sycl::event inclusive_scan_iter_1d(sycl::queue &exec_q,
                                    std::vector<sycl::event> &host_tasks,
                                    const std::vector<sycl::event> &depends = {})
 {
-    ScanOpT scan_op = ScanOpT();
+    ScanOpT scan_op{};
     constexpr outputT identity = su_ns::Identity<ScanOpT, outputT>::value;
 
     constexpr size_t _iter_nelems = 1;
@@ -352,9 +353,9 @@ sycl::event inclusive_scan_iter_1d(sycl::queue &exec_q,
         size_t n_groups_ = n_groups;
         size_t temp_size = 0;
         while (n_groups_ > 1) {
-            const auto this_size = (n_groups_ - 1);
+            const size_t this_size = (n_groups_ - 1);
             temp_size += this_size;
-            n_groups_ = ceiling_quotient<size_t>(this_size, chunk_size);
+            n_groups_ = ceiling_quotient(this_size, chunk_size);
         }
 
         // allocate