fix comments: recover int if necessary

azhai219 · azhai219 · commit 001443a88cfa · 2026-06-22T16:24:20.000+08:00
diff --git a/src/plugins/intel_cpu/CMakeLists.txt b/src/plugins/intel_cpu/CMakeLists.txt
@@ -8,18 +8,6 @@ endif()
 
 set(TARGET_NAME "openvino_intel_cpu_plugin")
 
-if(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
-    # C4267, 4244 issues from oneDNN headers conversion from 'XXX' to 'YYY', possible loss of data
-    ov_add_compiler_flags(/wd4018)
-    ov_add_compiler_flags(/wd4267)
-    ov_add_compiler_flags(/wd4244)
-    # mkldnn headers: '<<': result of 32-bit shift implicitly converted to 64 bits
-    ov_add_compiler_flags(/wd4334)
-    # oneDNN arm64: unary minus operator applied to unsigned type, result still unsigned
-    ov_add_compiler_flags(/wd4146)
-elseif (OV_COMPILER_IS_INTEL_LLVM AND WIN32)
-    ov_add_compiler_flags("/Wno-microsoft-include")
-endif()
 if(NOT BUILD_SHARED_LIBS)
     # Symbols are located in both src and include folders
     file(GLOB_RECURSE onednn_files
diff --git a/src/plugins/intel_cpu/src/nodes/ctc_loss.cpp b/src/plugins/intel_cpu/src/nodes/ctc_loss.cpp
@@ -84,9 +84,9 @@ void CTCLoss::execute([[maybe_unused]] const dnnl::stream& strm) {
     int32_t returnCode = 0;
 
     const auto* logits = getSrcDataAtPortAs<const float>(0);
-    const auto* logitsLength = getSrcDataAtPortAs<const int32_t>(1);
-    const auto* labels = getSrcDataAtPortAs<const int32_t>(2);
-    const auto* labelsLength = getSrcDataAtPortAs<const int32_t>(3);
+    const auto* logitsLength = getSrcDataAtPortAs<const int>(1);
+    const auto* labels = getSrcDataAtPortAs<const int>(2);
+    const auto* labelsLength = getSrcDataAtPortAs<const int>(3);
     auto* dstData = getDstDataAtPortAs<float>(0);
 
     const auto& inDims = getParentEdgeAt(0)->getMemory().getStaticDims();
@@ -99,8 +99,8 @@ void CTCLoss::execute([[maybe_unused]] const dnnl::stream& strm) {
         blankIndex = getSrcDataAtPortAs<const int32_t>(4)[0];
     }
 
-    std::vector<int32_t> decodedTargetLenB(batchNum, 0);
-    std::vector<std::vector<int32_t>> targetDB(batchNum);
+    std::vector<int> decodedTargetLenB(batchNum, 0);
+    std::vector<std::vector<int>> targetDB(batchNum);
     std::vector<std::vector<std::vector<float>>> logProbabilitiesB(batchNum);
     const auto threads_num = parallel_get_max_threads();
     std::vector<std::string> errorMsgB(threads_num);
@@ -268,16 +268,16 @@ void CTCLoss::execute([[maybe_unused]] const dnnl::stream& strm) {
         for (size_t b = start; b < end; b++) {
             auto& targetD = targetDB[b];
             auto& logProbabilities = logProbabilitiesB[b];
-            const int32_t actualLogitLen = logitsLength[b];
-            const int32_t decodedTargetLen = decodedTargetLenB[b];
+            const int actualLogitLen = logitsLength[b];
+            const int decodedTargetLen = decodedTargetLenB[b];
             std::vector<std::vector<float>> logBwd(decodedTargetLen, std::vector<float>(actualLogitLen, -float_inf));
-            for (int32_t s = decodedTargetLen - 2; s < decodedTargetLen; s++) {
+            for (int s = decodedTargetLen - 2; s < decodedTargetLen; s++) {
                 logBwd[s][actualLogitLen - 1] = 0.F;
             }
 
-            for (int32_t t = actualLogitLen - 2; t >= 0; t--) {
-                const int32_t t_1 = t + 1;
-                for (int32_t s = std::max(0, decodedTargetLen - (2 * (actualLogitLen - t)));
+            for (int t = actualLogitLen - 2; t >= 0; t--) {
+                const int t_1 = t + 1;
+                for (int s = std::max(0, decodedTargetLen - (2 * (actualLogitLen - t)));
                      s < std::min(decodedTargetLen, 2 * (t_1));
                      s++) {
                     if (ctcMergeRepeated || targetD[s] == blankIndex) {
diff --git a/src/plugins/intel_cpu/src/nodes/executors/eltwise_stateful_executor.cpp b/src/plugins/intel_cpu/src/nodes/executors/eltwise_stateful_executor.cpp
@@ -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 (int32_t i = static_cast<int32_t>(offset.size()) - 1; i >= 0; i--) {
+        for (auto i = static_cast<int32_t>(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 (int32_t i = static_cast<int32_t>(offset.size()) - 1; i >= 0; i--) {
+        for (auto i = static_cast<int32_t>(offset.size()) - 1; i >= 0; i--) {
             offset[i] = (inDims[i] == dims_out[i]) ? k : 0;
             k *= inDims[i];
         }
diff --git a/src/plugins/intel_cpu/src/nodes/executors/ref/eltwise.cpp b/src/plugins/intel_cpu/src/nodes/executors/ref/eltwise.cpp
@@ -372,7 +372,14 @@ void EltwiseRefExecutor<T, Enable>::exec(const jit_eltwise_call_args_ptrs& args_
                 *dst_ptr_f = src_f[0] || src_f[1];
                 break;
             case Algorithm::EltwiseLogicalXor:
+#ifdef _MSC_VER
+#    pragma warning(push)
+#    pragma warning(disable : 4244)
+#endif
                 *dst_ptr_f = static_cast<T>((src_f[0] || src_f[1]) - (src_f[0] && src_f[1]));
+#ifdef _MSC_VER
+#    pragma warning(pop)
+#endif
                 break;
             case Algorithm::EltwiseLogicalNot:
                 *dst_ptr_f = !src_f[0];
diff --git a/src/plugins/intel_cpu/src/nodes/executors/transpose.cpp b/src/plugins/intel_cpu/src/nodes/executors/transpose.cpp
@@ -6,6 +6,7 @@
 
 #include <algorithm>
 #include <cstddef>
+#include <cstdint>
 #include <iterator>
 #include <utility>
 #include <vector>
@@ -25,10 +26,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 (int i = static_cast<int>(params.src_block_dims.size()) - 2; i >= 0; i--) {
+    for (auto i = static_cast<int32_t>(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 (int i = static_cast<int>(params.dst_block_dims.size()) - 2; i >= 0; i--) {
+    for (auto i = static_cast<int32_t>(params.dst_block_dims.size()) - 2; i >= 0; i--) {
         dst_block_strides[i] = dst_block_strides[i + 1] * params.dst_block_dims[i + 1];
     }
 
@@ -43,7 +44,7 @@ jit_permute_config_params TransposeExecutor::prepareParams(const PermuteParams&
         tmp_order.push_back(params.order[params.dst_block_order[i]]);
     }
 
-    for (int i = static_cast<int>(tmp_order.size()) - 1; i >= 0; i--) {
+    for (auto i = static_cast<int32_t>(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) {
diff --git a/src/plugins/intel_cpu/src/nodes/if.h b/src/plugins/intel_cpu/src/nodes/if.h
@@ -56,8 +56,8 @@ class If : public Node {
     static std::deque<MemoryPtr> getToMemories(const Node* node, int32_t port);
 
     struct PortMap {
-        int32_t from; /**< Index of external/internal out data */
-        int32_t to;   /**< Index of external/internal in data */
+        int from; /**< Index of external/internal out data */
+        int to;   /**< Index of external/internal in data */
     };
 
     class PortMapHelper {
diff --git a/src/plugins/intel_cpu/src/nodes/multiclass_nms.cpp b/src/plugins/intel_cpu/src/nodes/multiclass_nms.cpp
@@ -517,8 +517,8 @@ void MultiClassNms::nmsWithEta(const float* boxes,
                 slice_class(batch_idx, class_idx, scores, scoresStrides, false, roisnum, roisnumStrides, shared);
 
             std::priority_queue<boxInfo, std::vector<boxInfo>, decltype(less)> sorted_boxes(less);
-            int32_t cur_numBoxes = shared ? static_cast<int32_t>(m_numBoxes) : roisnum[batch_idx];
-            for (int32_t box_idx = 0; box_idx < cur_numBoxes; box_idx++) {
+            int cur_numBoxes = shared ? static_cast<int>(m_numBoxes) : roisnum[batch_idx];
+            for (int box_idx = 0; box_idx < cur_numBoxes; box_idx++) {
                 if (scoresPtr[box_idx] >= m_scoreThreshold) {  // algin with ref
                     sorted_boxes.emplace(boxInfo({scoresPtr[box_idx], box_idx, 0}));
                 }
diff --git a/src/plugins/intel_cpu/src/nodes/pad.h b/src/plugins/intel_cpu/src/nodes/pad.h
@@ -49,8 +49,8 @@ class Pad : public Node {
         float padValue = 0.F;
         VectorIdxs padsBegin;
         VectorIdxs padsEnd;
-        int32_t beginPadIdx = 0;
-        int32_t endPadIdx = 0;
+        int beginPadIdx = 0;
+        int endPadIdx = 0;
         ov::element::Type prc;
         bool constPadValue = false;
         std::shared_ptr<CpuParallel> cpuParallel;
diff --git a/src/plugins/intel_cpu/src/nodes/reverse_sequence.cpp b/src/plugins/intel_cpu/src/nodes/reverse_sequence.cpp
@@ -62,12 +62,12 @@ ReverseSequence::ReverseSequence(const std::shared_ptr<ov::Node>& op, const Grap
 
     CPU_NODE_ASSERT(dataRank == getOutputShapeAtPort(0).getRank(), "has input/output rank mismatch");
 
-    seq_axis = static_cast<int32_t>(revSeq->get_sequence_axis());
+    seq_axis = static_cast<int>(revSeq->get_sequence_axis());
 
-    CPU_NODE_ASSERT(seq_axis >= 0 && seq_axis < static_cast<int32_t>(dataRank),
+    CPU_NODE_ASSERT(seq_axis >= 0 && seq_axis < static_cast<int>(dataRank),
                     "has incorrect 'seq_axis' parameters dimensions and axis number!");
 
-    batch_axis = static_cast<int32_t>(revSeq->get_batch_axis());
+    batch_axis = static_cast<int>(revSeq->get_batch_axis());
 
     CPU_NODE_ASSERT(batch_axis >= 0 && batch_axis < static_cast<int>(dataRank),
                     "has incorrect 'batch_axis' parameters dimensions and axis number!");
diff --git a/src/plugins/intel_cpu/src/nodes/roll.cpp b/src/plugins/intel_cpu/src/nodes/roll.cpp
@@ -197,9 +197,9 @@ void Roll::RollExecutor::exec(const MemoryPtr& dataMemPtr,
     const VectorDims& dataDims = dataMemPtr->getStaticDims();
 
     for (size_t dim = 0; dim < axesLength; ++dim) {
-        int currentAxis = axes[dim] < 0 ? axes[dim] + static_cast<int>(numOfDims) : axes[dim];
-        auto shiftSum = static_cast<int>(shiftsVector[currentAxis]) + shift[dim];
-        auto dimSize = static_cast<int>(dataDims[currentAxis]);
+        int32_t currentAxis = axes[dim] < 0 ? axes[dim] + static_cast<int32_t>(numOfDims) : axes[dim];
+        auto shiftSum = static_cast<int32_t>(shiftsVector[currentAxis]) + shift[dim];
+        auto dimSize = static_cast<int32_t>(dataDims[currentAxis]);
         shiftsVector[currentAxis] = (shiftSum % dimSize + dimSize) % dimSize;
     }
 
@@ -220,7 +220,7 @@ void Roll::RollExecutor::exec(const MemoryPtr& dataMemPtr,
         size_t leftBlockStartOffset = start;
         size_t rightBlockStartOffset = start + leftBlockSize;
 
-        for (int32_t dim = static_cast<int32_t>(numOfDims) - 1; dim >= 0; --dim) {
+        for (auto dim = static_cast<int>(numOfDims) - 1; dim >= 0; --dim) {
             leftBlockStartOffset =
                 calculateShiftOffset(leftBlockStartOffset, shiftsVector[dim], strides[dim], dataDims[dim]);
             rightBlockStartOffset =
diff --git a/src/plugins/intel_cpu/src/nodes/scatter_update.cpp b/src/plugins/intel_cpu/src/nodes/scatter_update.cpp
@@ -348,7 +348,7 @@ int64_t ScatterUpdate::getIndicesValue(uint8_t* indices, size_t offset) const {
 static std::vector<size_t> getBlockND(const VectorDims& shape) {
     auto shapeRank = static_cast<int32_t>(shape.size());
     std::vector<size_t> blockND(shapeRank + 1, 1);
-    for (int32_t i = shapeRank - 1; i >= 0; i--) {
+    for (auto i = shapeRank - 1; i >= 0; i--) {
         blockND[i] = shape[i] * blockND[i + 1];
     }
     return blockND;
@@ -376,7 +376,7 @@ static T reduction_neutral_value(const ScatterUpdate::Reduction reduction_type)
 
 static inline void getCoordinate(VectorDims& coordinate, size_t offset, const VectorDims& shape) {
     auto shapeRank = static_cast<int32_t>(shape.size());
-    for (int32_t i = shapeRank - 1; i >= 0; i--) {
+    for (auto i = shapeRank - 1; i >= 0; i--) {
         coordinate[i] = offset % shape[i];
         offset /= shape[i];
     }
diff --git a/src/plugins/intel_cpu/src/nodes/shuffle_channels.cpp b/src/plugins/intel_cpu/src/nodes/shuffle_channels.cpp
@@ -310,7 +310,7 @@ void ShuffleChannels::executeDynamicImpl(const dnnl::stream& strm) {
 void ShuffleChannels::execute([[maybe_unused]] const dnnl::stream& strm) {
     CPU_NODE_ASSERT(execPtr, "doesn't have a compiled executor.");
 
-    int MB = (attrs.axis != 0) ? static_cast<int32_t>(getSrcMemoryAtPort(0)->getStaticDims()[0]) : -1;
+    int MB = (attrs.axis != 0) ? static_cast<int>(getSrcMemoryAtPort(0)->getStaticDims()[0]) : -1;
 
     const auto* srcData = getSrcDataAtPortAs<const uint8_t>(0);
     auto* dstData = getDstDataAtPortAs<uint8_t>(0);
diff --git a/src/plugins/intel_cpu/src/nodes/space_to_depth.cpp b/src/plugins/intel_cpu/src/nodes/space_to_depth.cpp
@@ -324,7 +324,7 @@ void SpaceToDepth::execute([[maybe_unused]] const dnnl::stream& strm) {
     CPU_NODE_ASSERT(execPtr, "doesn't have a compiled executor.");
     const auto* srcData = getSrcDataAtPortAs<const uint8_t>(0);
     auto* dstData = getDstDataAtPortAs<uint8_t>(0);
-    const auto MB = static_cast<int32_t>(getSrcMemoryAtPort(0)->getStaticDims()[0]);
+    const auto MB = static_cast<int>(getSrcMemoryAtPort(0)->getStaticDims()[0]);
     execPtr->exec(srcData, dstData, MB, context->getCpuParallel());
 }
 
diff --git a/src/plugins/intel_cpu/src/nodes/strided_slice.cpp b/src/plugins/intel_cpu/src/nodes/strided_slice.cpp
@@ -555,15 +555,15 @@ void StridedSlice::StridedSliceCommonExecutor::dimsNormalization() {
         idx = (idx < max) ? idx : (max - 1);
     };
 
-    auto correcting = [](int32_t& dim, const size_t shift) {
-        dim = dim >= 0 ? dim : static_cast<int32_t>(shift) + dim;
+    auto correcting = [](int& dim, const size_t shift) {
+        dim = dim >= 0 ? dim : static_cast<int>(shift) + dim;
     };
 
     VectorDims newSrcDims;
     VectorDims newDstDims;
-    std::vector<int32_t> beginTemp;
-    std::vector<int32_t> endTemp;
-    std::vector<int32_t> strideTemp;
+    std::vector<int> beginTemp;
+    std::vector<int> endTemp;
+    std::vector<int> strideTemp;
     size_t srcIdx = 0;
     for (size_t axis = 0; axis < params.attrs.begin.size(); ++axis) {
         if (params.attrs.ellipsisMask[axis] == 1) {
@@ -588,7 +588,7 @@ void StridedSlice::StridedSliceCommonExecutor::dimsNormalization() {
                 newSrcDims.push_back(params.srcBlockedDims[srcIdx]);
                 newDstDims.push_back(params.srcBlockedDims[srcIdx]);
                 beginTemp.push_back(0);
-                endTemp.push_back(static_cast<int32_t>(params.srcBlockedDims[srcIdx]) - 1);
+                endTemp.push_back(static_cast<int>(params.srcBlockedDims[srcIdx]) - 1);
                 strideTemp.push_back(1);
 
                 srcIdx++;
@@ -601,9 +601,9 @@ void StridedSlice::StridedSliceCommonExecutor::dimsNormalization() {
                 newSrcDims.push_back(1);
                 newDstDims.push_back(1);
             } else if (params.attrs.shrinkAxisMask[axis] == 1) {
-                int32_t b = params.attrs.beginMask[axis] == 1 ? params.attrs.begin[axis] : 0;
+                auto b = params.attrs.beginMask[axis] == 1 ? params.attrs.begin[axis] : 0;
                 correcting(b, params.srcBlockedDims[srcIdx]);
-                clipping(b, 0, static_cast<int32_t>(params.srcBlockedDims[srcIdx]));
+                clipping(b, 0, static_cast<int>(params.srcBlockedDims[srcIdx]));
                 beginTemp.push_back(b);
                 endTemp.push_back(b);
                 strideTemp.push_back(1);
@@ -612,7 +612,7 @@ void StridedSlice::StridedSliceCommonExecutor::dimsNormalization() {
 
                 srcIdx++;
             } else {
-                int32_t b = [&]() {
+                int b = [&]() {
                     if (params.attrs.beginMask[axis] == 1) {
                         return params.attrs.begin[axis];
                     }
@@ -622,7 +622,7 @@ void StridedSlice::StridedSliceCommonExecutor::dimsNormalization() {
                     return -1;
                 }();
                 correcting(b, params.srcBlockedDims[srcIdx]);
-                clipping(b, 0, static_cast<int32_t>(params.srcBlockedDims[srcIdx]));
+                clipping(b, 0, static_cast<int>(params.srcBlockedDims[srcIdx]));
 
                 int e = [&]() {
                     if (params.attrs.endMask[axis] == 1) {
@@ -637,7 +637,7 @@ void StridedSlice::StridedSliceCommonExecutor::dimsNormalization() {
                     return 0;
                 }();
                 correcting(e, params.srcBlockedDims[srcIdx]);
-                clipping(e, 0, static_cast<int32_t>(params.srcBlockedDims[srcIdx]));
+                clipping(e, 0, static_cast<int>(params.srcBlockedDims[srcIdx]));
 
                 beginTemp.push_back(b);
                 endTemp.push_back(e);
@@ -748,7 +748,7 @@ void StridedSlice::StridedSliceCommonExecutor::dimsGluing() {
         params.srcStrides.insert(params.srcStrides.begin() + 1, params.srcStrides[0] / realSrcDim);
 
         for (size_t idx = secondDim.first + 1; idx < secondDim.second; idx++) {
-            params.attrs.begin[1] /= static_cast<int32_t>(dstBlockedDimsBefore[idx]);
+            params.attrs.begin[1] /= static_cast<int>(dstBlockedDimsBefore[idx]);
         }
 
         if (params.dstBlockedDims[0] < m_threads_num) {
@@ -811,7 +811,7 @@ void StridedSlice::StridedSliceCommonExecutor::indicesCalculation() {
         return srcIdx * params.attrs.dataSize;
     };
 
-    parallel_nt(static_cast<int32_t>(nThreads), [&](const int32_t ithr, const int32_t nthr) {
+    parallel_nt(static_cast<int>(nThreads), [&](const int ithr, const int nthr) {
         size_t start = 0;
         size_t end = 0;
         VectorDims coords(params.nDimsForWork, 0);
@@ -867,7 +867,7 @@ void StridedSlice::StridedSliceCommonExecutor::execStridedSlice(const std::vecto
     const auto* srcData = srcMemory[0]->getDataAs<const uint8_t>();
     auto* dstData = dstMemory[0]->getDataAs<uint8_t>();
     const uint8_t* srcShiftedData = srcData + srcShift;
-    parallel_nt(static_cast<int32_t>(nThreads), [&](const int32_t ithr, const int32_t nthr) {
+    parallel_nt(static_cast<int>(nThreads), [&](const int ithr, const int nthr) {
         size_t start = 0;
         size_t end = 0;
         splitter(workAmount, nthr, ithr, start, end);
@@ -889,7 +889,7 @@ void StridedSlice::StridedSliceCommonExecutor::execSliceScatter(const std::vecto
         return;
     }
     uint8_t* dstShiftedData = dstData + srcShift;
-    parallel_nt(static_cast<int32_t>(nThreads), [&](const int32_t ithr, const int32_t nthr) {
+    parallel_nt(static_cast<int>(nThreads), [&](const int ithr, const int nthr) {
         size_t start = 0;
         size_t end = 0;
         splitter(workAmount, nthr, ithr, start, end);
diff --git a/src/plugins/intel_cpu/src/nodes/tensoriterator.cpp b/src/plugins/intel_cpu/src/nodes/tensoriterator.cpp
@@ -126,7 +126,7 @@ class PortIteratorHelper : public PortMapHelper {
         auto abs_stride = std::abs(stride);
         auto sign_of_stride = stride < 0 ? -1 : 1;
 
-        iter_count = static_cast<int32_t>(full_dims[axis] / abs_stride);
+        iter_count = static_cast<int>(full_dims[axis] / abs_stride);
 
         full_dims[axis] = abs_stride;
         OPENVINO_ASSERT(full_dims == part_dims, "Shape mismatch for tensor iterator port");
diff --git a/src/plugins/intel_cpu/src/nodes/tile.cpp b/src/plugins/intel_cpu/src/nodes/tile.cpp
@@ -221,9 +221,9 @@ void Tile::plainExecute([[maybe_unused]] const dnnl::stream& strm) {
         m_outer_dim /= 16;
     }
 
-    m_inner_dim *= static_cast<int32_t>(srcMemory.getDesc().getPrecision().size());
-    for (int32_t i = 0; i < m_outer_dim; ++i) {
-        for (int32_t t = 0; t < tiles; ++t) {
+    m_inner_dim *= static_cast<int>(srcMemory.getDesc().getPrecision().size());
+    for (int i = 0; i < m_outer_dim; ++i) {
+        for (int t = 0; t < tiles; ++t) {
             cpu_memcpy(dst_ptr, src_ptr, m_inner_dim);
             dst_ptr += m_inner_dim;
         }
diff --git a/src/plugins/intel_cpu/src/nodes/unique.cpp b/src/plugins/intel_cpu/src/nodes/unique.cpp
diff --git a/src/plugins/intel_cpu/src/plugin.cpp b/src/plugins/intel_cpu/src/plugin.cpp
