fix int32_t

Author: azhai219

src/plugins/intel_cpu/src/emitters/plugin/x64/jit_bf16_emitters.hpp

@@ -60,7 +60,7 @@ class jit_uni_vcvtneps2bf16 : public jit_emitter {
             conditional3<isa == dnnl::impl::cpu::x64::sse41, Xmm, isa == dnnl::impl::cpu::x64::avx2, Ymm, Zmm>::type;
 
         const auto to_reg_idx = [](size_t idx) {
-            return static_cast<int32_t>(idx);
+            return static_cast<int>(idx);
         };
 
         auto in = Vmm(to_reg_idx(in_vec_idxs[0]));

src/plugins/intel_cpu/src/mlas/sgemm.cpp

@@ -38,7 +38,7 @@ void mlas_sgemm(const char* transa,
                 const float beta,
                 float* C,
                 const int64_t ldc,
-                int32_t thread_num) {
+                int thread_num) {
     // C = alpha*op( A )op( B ) + beta * C
     MLAS_SGEMM_DATA_PARAMS sgemmParam;
     sgemmParam.BIsPacked = false;
@@ -70,7 +70,7 @@ void mlas_sgemm_compute(const char* transa,
                         float* C,
                         const int64_t ldc,
                         const float* bias,
-                        int32_t thread_num) {
+                        int thread_num) {
     // C = alpha*op( A )op( B ) + beta * C
     ov::cpu::OVMlasThreadPool threadPool(0 == thread_num ? parallel_get_max_threads() : thread_num);
     MLAS_SGEMM_DATA_PARAMS sgemmParam;

src/plugins/intel_cpu/src/mlas/sgemm.hpp

@@ -62,7 +62,7 @@ void mlas_sgemm(const char* transa,
                 float beta,
                 float* C,
                 int64_t ldc,
-                int32_t thread_num = 0);
+                int thread_num = 0);
 
 /**
  * @brief SGEMM with B matrix prepacked
@@ -98,5 +98,5 @@ void mlas_sgemm_compute(const char* transa,
                         float* C,
                         int64_t ldc,
                         const float* bias = nullptr,
-                        int32_t thread_num = 0);
+                        int thread_num = 0);
 }  // namespace ov::intel_cpu

src/plugins/intel_cpu/src/mlas/thread_pool.hpp

@@ -14,13 +14,13 @@ namespace cpu {
 class OVMlasThreadPool : public IMlasThreadPool {
 public:
     OVMlasThreadPool() = delete;
-    explicit OVMlasThreadPool(const int32_t& threadNum) : threadNum(threadNum) {}
+    explicit OVMlasThreadPool(const int& threadNum) : threadNum(threadNum) {}
     virtual ~OVMlasThreadPool() = default;
     size_t DegreeOfParallelism() override;
     void TrySimpleParallelFor(std::ptrdiff_t total, const std::function<void(std::ptrdiff_t)>& fn) override;
 
     // the actual threads used for sgemm
-    int32_t threadNum = 0;
+    int threadNum = 0;
 };
 };  // namespace cpu
 };  // namespace ov

src/plugins/intel_cpu/src/nodes/common/permute_kernel.cpp

@@ -216,11 +216,11 @@ void PermuteKernel::execute(const uint8_t* src_data,
 void PermuteKernel::execute(const uint8_t* src_data, uint8_t* dst_data, const CpuParallelPtr& cpu_parallel) {
     VectorDims dst_dims = jcp.dst_block_dims;
     if (permute_kernel) {
-        optimizedExecute(src_data, dst_data, static_cast<int32_t>(dst_dims[0]), cpu_parallel);
+        optimizedExecute(src_data, dst_data, static_cast<int>(dst_dims[0]), cpu_parallel);
         return;
     }
 
-    RefTransposeExecutor::referenceExecute(src_data, dst_data, jcp, static_cast<int32_t>(dst_dims[0]));
+    RefTransposeExecutor::referenceExecute(src_data, dst_data, jcp, static_cast<int>(dst_dims[0]));
 }
 
 void PermuteKernel::optimizedExecute(const uint8_t* src_data,

src/plugins/intel_cpu/src/nodes/concat.cpp

@@ -580,7 +580,7 @@ void Concat::execute(const dnnl::stream& strm) {
             if (srcMem.getShape().hasZeroDims()) {
                 continue;
             }
-            mem_ags[DNNL_ARG_MULTIPLE_SRC + static_cast<int32_t>(nonZeroInShapes)] = srcMem.getPrimitive();
+            mem_ags[DNNL_ARG_MULTIPLE_SRC + static_cast<int>(nonZeroInShapes)] = srcMem.getPrimitive();
             nonZeroInShapes++;
         }
         prim.execute(strm, mem_ags);
@@ -631,7 +631,7 @@ void Concat::execNspcSpecCase() {
         channels_size += num_channels * dataSize;
 
         if (firstNonZeroEdge == -1) {
-            firstNonZeroEdge = static_cast<int32_t>(i);
+            firstNonZeroEdge = static_cast<int>(i);
         }
 
         nonZeroInShapes++;

src/plugins/intel_cpu/src/nodes/ctc_loss.cpp

@@ -94,9 +94,9 @@ void CTCLoss::execute([[maybe_unused]] const dnnl::stream& strm) {
     const size_t maxTime = inDims[1];
     const size_t classesNum = inDims[2];
 
-    auto blankIndex = static_cast<int32_t>(classesNum) - 1;
+    auto blankIndex = static_cast<int>(classesNum) - 1;
     if (inputShapes.size() > 4) {
-        blankIndex = getSrcDataAtPortAs<const int32_t>(4)[0];
+        blankIndex = getSrcDataAtPortAs<const int>(4)[0];
     }
 
     std::vector<int> decodedTargetLenB(batchNum, 0);
@@ -164,7 +164,7 @@ void CTCLoss::execute([[maybe_unused]] const dnnl::stream& strm) {
                 }
                 targetD[decodedTargetLen++] = blankIndex;
             }
-            decodedTargetLenB[b] = static_cast<int32_t>(decodedTargetLen);
+            decodedTargetLenB[b] = static_cast<int>(decodedTargetLen);
 
             auto& logProbabilities = logProbabilitiesB[b];
             logProbabilities.resize(actualLogitLen);

src/plugins/intel_cpu/src/nodes/executors/eltwise_stateful_executor.cpp

@@ -67,17 +67,17 @@ EltwiseStatefulExecutor::EltwiseStatefulExecutor(EltwiseAttrs attrs,
         eltwiseImplType = EltwiseImplType::reference;
     }
 
-    auto inputNum = static_cast<int32_t>(memory.size()) - 1;  // -1 for output
+    auto inputNum = static_cast<int>(memory.size()) - 1;  // -1 for output
 
-    for (int32_t i = 0; i < inputNum; i++) {
+    for (int i = 0; i < inputNum; i++) {
         const auto desc = memory.at(i + ARG_SRC)->getDescWithType<BlockedMemoryDesc>();
         m_srcOffsets.push_back(desc->getOffsetPadding() * desc->getPrecision().size());
     }
 
     const auto desc = memory.at(ARG_DST)->getDescWithType<BlockedMemoryDesc>();
     m_dstOffset = desc->getOffsetPadding() * desc->getPrecision().size();
 
-    for (int32_t i = 0; i < inputNum; ++i) {
+    for (int i = 0; i < inputNum; ++i) {
         m_inpPrc.push_back(memory.at(i + ARG_SRC)->getDesc().getPrecision());
     }
     m_outPrc = memory.at(ARG_DST)->getDesc().getPrecision();
@@ -232,15 +232,15 @@ void EltwiseStatefulExecutor::updateExecutionParams(const std::vector<VectorDims
     // offsets recalculation
     auto offset_out_calc = [](VectorDims& offset, const VectorDims& dims) {
         size_t k = 1;
-        for (auto i = static_cast<int32_t>(offset.size()) - 1; i >= 0; i--) {
+        for (auto i = static_cast<int>(offset.size()) - 1; i >= 0; i--) {
             offset[i] = k;
             k *= dims[i];
         }
     };
 
     auto offset_in_calc = [](VectorDims& offset, const VectorDims& inDims, const VectorDims& dims_out) {
         size_t k = 1;
-        for (auto i = static_cast<int32_t>(offset.size()) - 1; i >= 0; i--) {
+        for (auto i = static_cast<int>(offset.size()) - 1; i >= 0; i--) {
             offset[i] = (inDims[i] == dims_out[i]) ? k : 0;
             k *= inDims[i];
         }

src/plugins/intel_cpu/src/nodes/executors/transpose.cpp

@@ -6,7 +6,6 @@
 
 #include <algorithm>
 #include <cstddef>
-#include <cstdint>
 #include <iterator>
 #include <utility>
 #include <vector>
@@ -26,10 +25,10 @@ jit_permute_config_params TransposeExecutor::prepareParams(const PermuteParams&
     VectorDims src_block_order = params.src_block_order;
     VectorDims src_block_strides(params.src_block_dims.size(), 1);
     VectorDims dst_block_strides(params.dst_block_dims.size(), 1);
-    for (auto i = static_cast<int32_t>(params.src_block_dims.size()) - 2; i >= 0; i--) {
+    for (auto i = static_cast<int>(params.src_block_dims.size()) - 2; i >= 0; i--) {
         src_block_strides[i] = src_block_strides[i + 1] * params.src_block_dims[i + 1];
     }
-    for (auto i = static_cast<int32_t>(params.dst_block_dims.size()) - 2; i >= 0; i--) {
+    for (auto i = static_cast<int>(params.dst_block_dims.size()) - 2; i >= 0; i--) {
         dst_block_strides[i] = dst_block_strides[i + 1] * params.dst_block_dims[i + 1];
     }
 
@@ -44,7 +43,7 @@ jit_permute_config_params TransposeExecutor::prepareParams(const PermuteParams&
         tmp_order.push_back(params.order[params.dst_block_order[i]]);
     }
 
-    for (auto i = static_cast<int32_t>(tmp_order.size()) - 1; i >= 0; i--) {
+    for (auto i = static_cast<int>(tmp_order.size()) - 1; i >= 0; i--) {
         auto pos = std::distance(std::find(src_block_order.rbegin(), src_block_order.rend(), tmp_order[i]),
                                  src_block_order.rend() - 1);
         if (pos != -1) {

src/plugins/intel_cpu/src/nodes/experimental_detectron_detection_output.cpp

@@ -273,8 +273,8 @@ ExperimentalDetectronDetectionOutput::ExperimentalDetectronDetectionOutput(const
     score_threshold_ = attributes.score_threshold;
     nms_threshold_ = attributes.nms_threshold;
     max_delta_log_wh_ = attributes.max_delta_log_wh;
-    classes_num_ = static_cast<int32_t>(attributes.num_classes);
-    max_detections_per_class_ = static_cast<int32_t>(attributes.post_nms_count);
+    classes_num_ = static_cast<int>(attributes.num_classes);
+    max_detections_per_class_ = static_cast<int>(attributes.post_nms_count);
     max_detections_per_image_ = attributes.max_detections_per_image;
     class_agnostic_box_regression_ = attributes.class_agnostic_box_regression;
     deltas_weights_ = attributes.deltas_weights;
@@ -299,9 +299,9 @@ void ExperimentalDetectronDetectionOutput::initSupportedPrimitiveDescriptors() {
 }
 
 void ExperimentalDetectronDetectionOutput::execute([[maybe_unused]] const dnnl::stream& strm) {
-    const auto rois_num = static_cast<int32_t>(getParentEdgeAt(INPUT_ROIS)->getMemory().getStaticDims()[0]);
-    assert(classes_num_ == static_cast<int32_t>(getParentEdgeAt(INPUT_SCORES)->getMemory().getStaticDims()[1]));
-    assert(4 * classes_num_ == static_cast<int32_t>(getParentEdgeAt(INPUT_DELTAS)->getMemory().getStaticDims()[1]));
+    const auto rois_num = static_cast<int64_t>(getParentEdgeAt(INPUT_ROIS)->getMemory().getStaticDims()[0]);
+    assert(classes_num_ == static_cast<int64_t>(getParentEdgeAt(INPUT_SCORES)->getMemory().getStaticDims()[1]));
+    assert(4 * classes_num_ == static_cast<int64_t>(getParentEdgeAt(INPUT_DELTAS)->getMemory().getStaticDims()[1]));
 
     const auto* boxes = getSrcDataAtPortAs<const float>(INPUT_ROIS);
     const auto* deltas = getSrcDataAtPortAs<const float>(INPUT_DELTAS);
@@ -315,8 +315,8 @@ void ExperimentalDetectronDetectionOutput::execute([[maybe_unused]] const dnnl::
     std::vector<float> refined_boxes(classes_num_ * rois_num * 4, 0);
     std::vector<float> refined_scores(classes_num_ * rois_num, 0);
     std::vector<float> refined_boxes_areas(classes_num_ * rois_num, 0);
-    Indexer refined_box_idx({classes_num_, rois_num, 4});
-    Indexer refined_score_idx({classes_num_, rois_num});
+    Indexer refined_box_idx({static_cast<int>(classes_num_), static_cast<int>(rois_num), 4});
+    Indexer refined_score_idx({static_cast<int>(classes_num_), static_cast<int>(rois_num)});
 
     refine_boxes(boxes,
                  deltas,
@@ -325,8 +325,8 @@ void ExperimentalDetectronDetectionOutput::execute([[maybe_unused]] const dnnl::
                  refined_boxes.data(),
                  refined_boxes_areas.data(),
                  refined_scores.data(),
-                 rois_num,
-                 classes_num_,
+                 static_cast<int>(rois_num),
+                 static_cast<int>(classes_num_),
                  max_delta_log_wh_,
                  1.0F);
 
@@ -343,7 +343,7 @@ void ExperimentalDetectronDetectionOutput::execute([[maybe_unused]] const dnnl::
                buffer.data(),
                &indices[total_detections_num],
                detections_per_class[class_idx],
-               rois_num,
+               static_cast<int>(rois_num),
                -1,
                static_cast<int>(max_detections_per_class_),
                score_threshold_,