Replaced int8_t->std::int8_t, same for other integral types

Added missing `#include <cstdint>`

Author: oleksandr-pavlyk

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

@@ -113,7 +113,7 @@ class ClipContigFunctor
             const std::uint16_t sgSize =
                 ndit.get_sub_group().get_local_range()[0];
             const std::size_t gid = ndit.get_global_linear_id();
-            const uint16_t nelems_per_sg = sgSize * nelems_per_wi;
+            const std::uint16_t nelems_per_sg = sgSize * nelems_per_wi;
 
             const std::size_t start =
                 (gid / sgSize) * (nelems_per_sg - sgSize) + gid;

dpctl/tensor/libtensor/include/kernels/elementwise_functions/conj.hpp

@@ -103,7 +103,7 @@ using ConjStridedFunctor = elementwise_common::
 template <typename T> struct ConjOutputType
 {
     using value_type = typename std::disjunction<
-        td_ns::TypeMapResultEntry<T, bool, int8_t>,
+        td_ns::TypeMapResultEntry<T, bool, std::int8_t>,
         td_ns::TypeMapResultEntry<T, std::uint8_t>,
         td_ns::TypeMapResultEntry<T, std::uint16_t>,
         td_ns::TypeMapResultEntry<T, std::uint32_t>,

dpctl/tensor/libtensor/include/utils/type_dispatch_building.hpp

@@ -26,6 +26,7 @@
 #pragma once
 
 #include <complex>
+#include <cstdint>
 #include <type_traits>
 
 #include <sycl/sycl.hpp>
@@ -69,14 +70,14 @@ class DispatchTableBuilder
     {
         std::vector<funcPtrT> per_dstTy = {
             factory<funcPtrT, dstTy, bool>{}.get(),
-            factory<funcPtrT, dstTy, int8_t>{}.get(),
-            factory<funcPtrT, dstTy, uint8_t>{}.get(),
-            factory<funcPtrT, dstTy, int16_t>{}.get(),
-            factory<funcPtrT, dstTy, uint16_t>{}.get(),
-            factory<funcPtrT, dstTy, int32_t>{}.get(),
-            factory<funcPtrT, dstTy, uint32_t>{}.get(),
-            factory<funcPtrT, dstTy, int64_t>{}.get(),
-            factory<funcPtrT, dstTy, uint64_t>{}.get(),
+            factory<funcPtrT, dstTy, std::int8_t>{}.get(),
+            factory<funcPtrT, dstTy, std::uint8_t>{}.get(),
+            factory<funcPtrT, dstTy, std::int16_t>{}.get(),
+            factory<funcPtrT, dstTy, std::uint16_t>{}.get(),
+            factory<funcPtrT, dstTy, std::int32_t>{}.get(),
+            factory<funcPtrT, dstTy, std::uint32_t>{}.get(),
+            factory<funcPtrT, dstTy, std::int64_t>{}.get(),
+            factory<funcPtrT, dstTy, std::uint64_t>{}.get(),
             factory<funcPtrT, dstTy, sycl::half>{}.get(),
             factory<funcPtrT, dstTy, float>{}.get(),
             factory<funcPtrT, dstTy, double>{}.get(),
@@ -93,24 +94,24 @@ class DispatchTableBuilder
     void populate_dispatch_table(funcPtrT table[][_num_types]) const
     {
         const auto map_by_dst_type = {row_per_dst_type<bool>(),
-                                      row_per_dst_type<int8_t>(),
-                                      row_per_dst_type<uint8_t>(),
-                                      row_per_dst_type<int16_t>(),
-                                      row_per_dst_type<uint16_t>(),
-                                      row_per_dst_type<int32_t>(),
-                                      row_per_dst_type<uint32_t>(),
-                                      row_per_dst_type<int64_t>(),
-                                      row_per_dst_type<uint64_t>(),
+                                      row_per_dst_type<std::int8_t>(),
+                                      row_per_dst_type<std::uint8_t>(),
+                                      row_per_dst_type<std::int16_t>(),
+                                      row_per_dst_type<std::uint16_t>(),
+                                      row_per_dst_type<std::int32_t>(),
+                                      row_per_dst_type<std::uint32_t>(),
+                                      row_per_dst_type<std::int64_t>(),
+                                      row_per_dst_type<std::uint64_t>(),
                                       row_per_dst_type<sycl::half>(),
                                       row_per_dst_type<float>(),
                                       row_per_dst_type<double>(),
                                       row_per_dst_type<std::complex<float>>(),
                                       row_per_dst_type<std::complex<double>>()};
         assert(map_by_dst_type.size() == _num_types);
         int dst_id = 0;
-        for (auto &row : map_by_dst_type) {
+        for (const auto &row : map_by_dst_type) {
             int src_id = 0;
-            for (auto &fn_ptr : row) {
+            for (const auto &fn_ptr : row) {
                 table[dst_id][src_id] = fn_ptr;
                 ++src_id;
             }
@@ -139,22 +140,22 @@ class DispatchVectorBuilder
     void populate_dispatch_vector(funcPtrT vector[]) const
     {
         const auto fn_map_by_type = {func_per_type<bool>(),
-                                     func_per_type<int8_t>(),
-                                     func_per_type<uint8_t>(),
-                                     func_per_type<int16_t>(),
-                                     func_per_type<uint16_t>(),
-                                     func_per_type<int32_t>(),
-                                     func_per_type<uint32_t>(),
-                                     func_per_type<int64_t>(),
-                                     func_per_type<uint64_t>(),
+                                     func_per_type<std::int8_t>(),
+                                     func_per_type<std::uint8_t>(),
+                                     func_per_type<std::int16_t>(),
+                                     func_per_type<std::uint16_t>(),
+                                     func_per_type<std::int32_t>(),
+                                     func_per_type<std::uint32_t>(),
+                                     func_per_type<std::int64_t>(),
+                                     func_per_type<std::uint64_t>(),
                                      func_per_type<sycl::half>(),
                                      func_per_type<float>(),
                                      func_per_type<double>(),
                                      func_per_type<std::complex<float>>(),
                                      func_per_type<std::complex<double>>()};
         assert(fn_map_by_type.size() == _num_types);
         int ty_id = 0;
-        for (auto &fn : fn_map_by_type) {
+        for (const auto &fn : fn_map_by_type) {
             vector[ty_id] = fn;
             ++ty_id;
         }

dpctl/tensor/libtensor/source/integer_advanced_indexing.cpp

@@ -245,7 +245,7 @@ usm_ndarray_take(const dpctl::tensor::usm_ndarray &src,
                  const py::object &py_ind,
                  const dpctl::tensor::usm_ndarray &dst,
                  int axis_start,
-                 uint8_t mode,
+                 std::uint8_t mode,
                  sycl::queue &exec_q,
                  const std::vector<sycl::event> &depends)
 {
@@ -560,7 +560,7 @@ usm_ndarray_put(const dpctl::tensor::usm_ndarray &dst,
                 const py::object &py_ind,
                 const dpctl::tensor::usm_ndarray &val,
                 int axis_start,
-                uint8_t mode,
+                std::uint8_t mode,
                 sycl::queue &exec_q,
                 const std::vector<sycl::event> &depends)
 {

dpctl/tensor/libtensor/source/integer_advanced_indexing.hpp

@@ -43,7 +43,7 @@ usm_ndarray_take(const dpctl::tensor::usm_ndarray &,
                  const py::object &,
                  const dpctl::tensor::usm_ndarray &,
                  int,
-                 uint8_t,
+                 std::uint8_t,
                  sycl::queue &,
                  const std::vector<sycl::event> & = {});
 
@@ -52,7 +52,7 @@ usm_ndarray_put(const dpctl::tensor::usm_ndarray &,
                 const py::object &,
                 const dpctl::tensor::usm_ndarray &,
                 int,
-                uint8_t,
+                std::uint8_t,
                 sycl::queue &,
                 const std::vector<sycl::event> & = {});