Fixes, style fixes and tests

Author: AlexanderKalistratov

dpnp/backend/extensions/statistics/histogram_common.hpp

@@ -310,9 +310,9 @@ class histogram_kernel;
 
 template <typename T, typename HistImpl, typename Edges, typename Weights>
 void submit_histogram(const T *in,
-                      size_t size,
-                      size_t dims,
-                      uint32_t WorkPI,
+                      const size_t size,
+                      const size_t dims,
+                      const uint32_t WorkPI,
                       const HistImpl &hist,
                       const Edges &edges,
                       const Weights &weights,

dpnp/backend/extensions/statistics/histogramdd.cpp

@@ -50,9 +50,9 @@ struct EdgesDd
     using boundsT = std::tuple<EdgesT *, EdgesT *>;
 
     EdgesDd(const EdgesT *global_edges,
-            size_t total_size,
+            const size_t total_size,
             const EdgesCountT *global_edges_sizes,
-            size_t dims,
+            const size_t dims,
             sycl::handler &cgh)
         : edges(global_edges, sycl::range<1>(total_size), cgh),
           edges_size(global_edges_sizes, sycl::range<1>(dims), cgh)
@@ -72,13 +72,13 @@ struct EdgesDd
             sycl::group_barrier(group, sycl::memory_scope::work_group);
         }
 
-        auto *edges_ptr = edges.get_ptr();
+        const auto *edges_ptr = edges.get_ptr();
         auto *min_ptr = &min[0];
         auto *max_ptr = &max[0];
 
         if (group.leader()) {
-            for (size_t i = 0; i < edges_size.size(); ++i) {
-                auto size = edges_size[i];
+            for (uint32_t i = 0; i < edges_size.size(); ++i) {
+                const auto size = edges_size[i];
                 min_ptr[i] = edges_ptr[0];
                 max_ptr[i] = edges_ptr[size - 1];
                 edges_ptr += size;
@@ -91,11 +91,11 @@ struct EdgesDd
         return {&min[0], &max[0]};
     }
 
-    size_t get_bin_for_dim(const EdgesT &val,
-                           const EdgesT *edges_data,
-                           uint32_t edges_count) const
+    auto get_bin_for_dim(const EdgesT &val,
+                         const EdgesT *edges_data,
+                         const uint32_t edges_count) const
     {
-        uint32_t bins_count = edges_count - 1;
+        const uint32_t bins_count = edges_count - 1;
 
         uint32_t bin = std::upper_bound(edges_data, edges_data + edges_count,
                                         val, Less<EdgesT>{}) -
@@ -106,18 +106,19 @@ struct EdgesDd
     }
 
     template <int _Dims, typename dT>
-    size_t get_bin(const sycl::nd_item<_Dims> &,
-                   const dT *val,
-                   const boundsT &) const
+    auto get_bin(const sycl::nd_item<_Dims> &,
+                 const dT *val,
+                 const boundsT &) const
     {
-        int32_t resulting_bin = 0;
-        auto *edges_ptr = &edges[0];
-        int32_t dims = edges_size.size();
+        uint32_t resulting_bin = 0;
+        const auto *edges_ptr = &edges[0];
+        const uint32_t dims = edges_size.size();
 
-        for (int i = 0; i < dims; ++i) {
-            int32_t curr_edges_count = edges_size[i];
+        for (uint32_t i = 0; i < dims; ++i) {
+            const uint32_t curr_edges_count = edges_size[i];
 
-            auto bin_id = get_bin_for_dim(val[i], edges_ptr, curr_edges_count);
+            const auto bin_id =
+                get_bin_for_dim(val[i], edges_ptr, curr_edges_count);
             resulting_bin = resulting_bin * (curr_edges_count - 1) + bin_id;
             edges_ptr += curr_edges_count;
         }
@@ -137,12 +138,12 @@ struct EdgesDd
     template <typename dT>
     bool in_bounds(const dT *val, const boundsT &bounds) const
     {
-        EdgesT *min = std::get<0>(bounds);
-        EdgesT *max = std::get<1>(bounds);
-        int32_t dims = edges_size.size();
+        const EdgesT *min = std::get<0>(bounds);
+        const EdgesT *max = std::get<1>(bounds);
+        const uint32_t dims = edges_size.size();
 
         auto in_bounds = true;
-        for (int i = 0; i < dims; ++i) {
+        for (uint32_t i = 0; i < dims; ++i) {
             in_bounds &= in_bounds_for_dim(val[i], min[i], max[i]);
         }
 
@@ -198,8 +199,8 @@ struct HistogramddF
         return exec_q.submit([&](sycl::handler &cgh) {
             cgh.depends_on(depends);
 
-            auto dispatch_edges = [&](uint32_t local_mem, const auto &weights,
-                                      auto &hist) {
+            auto dispatch_edges = [&](const uint32_t local_mem,
+                                      const auto &weights, auto &hist) {
                 if (device.is_gpu() && (local_mem >= total_edges)) {
                     auto edges = CachedEdgesDd<BinsT, EdgesCountT>(
                         bins_edges, total_edges, bins_edges_count, dims, cgh);
@@ -226,7 +227,8 @@ struct HistogramddF
 
                     auto hist = HistWithLocalCopies<HistType>(
                         out, bins_count, local_hist_count, cgh);
-                    uint32_t free_local_mem = local_mem_size - hist.size();
+                    const uint32_t free_local_mem =
+                        local_mem_size - hist.size();
 
                     dispatch_edges(free_local_mem, weights, hist);
                 }