[CPU] msvc: suppress warning in nodes/mlas directory (#35777)

### Details:
 - *fix the warning in cpu nodes/mlas directory code base in msvc*

### Tickets:
 - *184181*

### AI Assistance:
 - *AI assistance used: no / yes*
- *If yes, summarize how AI was used and what human validation was
performed (build/tests/manual checks).*

Author: azhai219

src/plugins/intel_cpu/CMakeLists.txt

@@ -8,18 +8,10 @@ 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)
+if (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

src/plugins/intel_cpu/src/cpu_parallel.cpp

@@ -4,14 +4,13 @@
 
 #include "cpu_parallel.hpp"
 
-#include <cstddef>
 #include <memory>
 
 #include "openvino/runtime/intel_cpu/properties.hpp"
 #include "thread_pool_imp.hpp"
 
 namespace ov::intel_cpu {
-CpuParallel::CpuParallel(ov::intel_cpu::TbbPartitioner partitioner, size_t multiplier)
+CpuParallel::CpuParallel(ov::intel_cpu::TbbPartitioner partitioner, int multiplier)
     : m_partitioner(partitioner),
       m_multiplier(multiplier) {
     m_partitioner =

src/plugins/intel_cpu/src/cpu_parallel.hpp

@@ -21,22 +21,21 @@ class CpuParallel {
     CpuParallel() = delete;
     CpuParallel(CpuParallel&) = delete;
     CpuParallel(ov::intel_cpu::TbbPartitioner partitioner = ov::intel_cpu::TbbPartitioner::STATIC,
-                size_t multiplier = default_multiplier);
+                int multiplier = default_multiplier);
     ~CpuParallel() = default;
 
     [[nodiscard]] ov::intel_cpu::TbbPartitioner get_partitioner() const {
         return m_partitioner;
     }
-    [[nodiscard]] size_t get_multiplier() const {
+    [[nodiscard]] int get_multiplier() const {
         return m_multiplier;
     }
     [[nodiscard]] std::shared_ptr<ThreadPool> get_thread_pool() const {
         return m_thread_pool;
     }
     [[nodiscard]] int get_num_threads() const {
-        int num = m_partitioner == ov::intel_cpu::TbbPartitioner::STATIC
-                      ? parallel_get_max_threads()
-                      : parallel_get_max_threads() * static_cast<int>(m_multiplier);
+        int num = m_partitioner == ov::intel_cpu::TbbPartitioner::STATIC ? parallel_get_max_threads()
+                                                                         : parallel_get_max_threads() * m_multiplier;
         return num;
     }
     [[nodiscard]] static int get_num_worker_threads() {

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

@@ -59,17 +59,21 @@ class jit_uni_vcvtneps2bf16 : public jit_emitter {
         using Vmm = typename dnnl::impl::utils::
             conditional3<isa == dnnl::impl::cpu::x64::sse41, Xmm, isa == dnnl::impl::cpu::x64::avx2, Ymm, Zmm>::type;
 
-        auto in = Vmm(in_vec_idxs[0]);
+        const auto to_reg_idx = [](size_t idx) {
+            return static_cast<int>(idx);
+        };
+
+        auto in = Vmm(to_reg_idx(in_vec_idxs[0]));
         if (mode_ == conversion_mode::saturation_mode) {
-            auto vmm_temp = Vmm(out_vec_idxs[0]);
+            auto vmm_temp = Vmm(to_reg_idx(out_vec_idxs[0]));
 
             h->uni_vmaxps(vmm_temp, in, table_val("bf16_min"));
             h->uni_vminps(vmm_temp, vmm_temp, table_val("bf16_max"));
 
             if (dnnl::impl::cpu::x64::mayiuse(dnnl::impl::cpu::x64::avx512_core)) {
                 h->vfixupimmps(vmm_temp, in, table_val("selector"), 0);
             } else {
-                auto mask = Vmm(aux_vec_idxs[0]);
+                auto mask = Vmm(to_reg_idx(aux_vec_idxs[0]));
                 h->uni_vcmpps(mask, in, in, 0x03);  // _CMP_UNORD_Q
                 h->uni_vblendvps(vmm_temp, vmm_temp, table_val("nan"), mask);
                 h->uni_vcmpps(mask, in, table_val("inf"), 0x00);  // _CMP_EQ_OQ
@@ -81,12 +85,12 @@ class jit_uni_vcvtneps2bf16 : public jit_emitter {
         }
 
         if (dnnl::impl::cpu::x64::mayiuse(dnnl::impl::cpu::x64::avx512_core_bf16)) {
-            auto out = Ymm(out_vec_idxs[0]);
+            auto out = Ymm(to_reg_idx(out_vec_idxs[0]));
             h->vcvtneps2bf16(out, in);
         } else if (host_isa_ == dnnl::impl::cpu::x64::cpu_isa_t::avx512_core) {
-            auto aux = Zmm(aux_vec_idxs[0]);
-            auto aux1 = Zmm(aux_vec_idxs[1]);
-            auto out = Ymm(out_vec_idxs[0]);
+            auto aux = Zmm(to_reg_idx(aux_vec_idxs[0]));
+            auto aux1 = Zmm(to_reg_idx(aux_vec_idxs[1]));
+            auto out = Ymm(to_reg_idx(out_vec_idxs[0]));
 
             h->uni_vpsrld(aux, in, 16);
             h->vpandd(aux, aux, table_val("one"));
@@ -97,11 +101,11 @@ class jit_uni_vcvtneps2bf16 : public jit_emitter {
             h->vpsrad(aux, aux, 16);
             h->vpmovdw(out, aux);
         } else if (dnnl::impl::cpu::x64::mayiuse(dnnl::impl::cpu::x64::cpu_isa_t::avx2_vnni_2)) {
-            auto out = Xmm(out_vec_idxs[0]);
+            auto out = Xmm(to_reg_idx(out_vec_idxs[0]));
             h->vcvtneps2bf16(out, in, PreferredEncoding::VexEncoding);
         } else {  // round_to_nearest_even emulation
-            auto aux = Vmm(aux_vec_idxs[0]);
-            auto out = Xmm(out_vec_idxs[0]);
+            auto aux = Vmm(to_reg_idx(aux_vec_idxs[0]));
+            auto out = Xmm(to_reg_idx(out_vec_idxs[0]));
 
             if (host_isa_ == dnnl::impl::cpu::x64::cpu_isa_t::avx2) {
                 h->uni_vandps(aux, in, table_val("rounding"));

src/plugins/intel_cpu/src/emitters/plugin/x64/jit_emitter.cpp

@@ -10,7 +10,6 @@
 #include <cassert>
 #include <cpu/x64/cpu_isa_traits.hpp>
 #include <cstddef>
-#include <cstdint>
 #include <memory>
 #include <set>
 #include <vector>
@@ -192,8 +191,8 @@ void jit_emitter::emitter_preamble(const std::vector<size_t>& in_idxs,
         aux_gpr_idxs.erase(aux_gpr_idxs.end() - 1);
     }
 
-    for (uint64_t preserved_gpr_idx : preserved_gpr_idxs) {
-        h->push(Reg64(preserved_gpr_idx));
+    for (auto preserved_gpr_idx : preserved_gpr_idxs) {
+        h->push(Reg64(static_cast<int>(preserved_gpr_idx)));
     }
 
     if (!preserved_vec_idxs.empty()) {

src/plugins/intel_cpu/src/emitters/snippets/x64/jit_loop_base_emitters.cpp

@@ -179,7 +179,7 @@ void jit_loop_end_base_emitter::apply_increments_to_ptrs(const std::vector<size_
                            h->ptr[reg_increments.value() + idx * sizeof(int64_t)]);
                 } else {
                     // Use pre-computed increment value from loop_args (already scaled)
-                    h->add(Reg64(static_cast<int>(data_ptr_reg_idxs[idx])), increment);
+                    h->add(Reg64(static_cast<int>(data_ptr_reg_idxs[idx])), static_cast<uint32_t>(increment));
                 }
             }
         }

src/plugins/intel_cpu/src/memory_desc/cpu_blocked_memory_desc.cpp

@@ -296,7 +296,7 @@ MemoryDescPtr CpuBlockedMemoryDesc::cloneWithNewDimsImp(const VectorDims& dims)
     }
 
     // TODO [DS]: add stride recalculation for strided blobs
-    for (int i = strides.size() - 2; i >= 0; i--) {
+    for (auto i = static_cast<int>(strides.size() - 2); i >= 0; i--) {
         if (strides[i] == Shape::UNDEFINED_DIM) {
             break;
         }

src/plugins/intel_cpu/src/memory_desc/dnnl_blocked_memory_desc.cpp

@@ -194,7 +194,7 @@ DnnlBlockedMemoryDesc::DnnlBlockedMemoryDesc(ov::element::Type prc,
     desc.get()->format_kind = dnnl_blocked;
     desc.get()->extra.flags = 0;
     desc.get()->data_type = memory::convert_to_c(DnnlExtensionUtils::ElementTypeToDataType(prc));
-    desc.get()->ndims = dims.size();
+    desc.get()->ndims = static_cast<int>(dims.size());
     desc.get()->offset0 = DnnlExtensionUtils::convertToDnnlDim(offsetPadding);
     std::copy(dims.begin(), dims.end(), desc.get()->dims);
 
@@ -227,7 +227,7 @@ DnnlBlockedMemoryDesc::DnnlBlockedMemoryDesc(ov::element::Type prc,
 
     // Fill blocking desc
     auto& dnn_blk_desc = desc.get()->format_desc.blocking;
-    dnn_blk_desc.inner_nblks = inner_ndims;
+    dnn_blk_desc.inner_nblks = static_cast<int>(inner_ndims);
     std::copy(dnnlBlkDims.end() - inner_ndims, dnnlBlkDims.end(), dnn_blk_desc.inner_blks);
     std::copy(order.end() - inner_ndims, order.end(), dnn_blk_desc.inner_idxs);
 
@@ -474,8 +474,8 @@ static dnnl::memory::desc cloneDescWithNewDims(const dnnl::memory::desc& desc,
     std::vector<int> perm(convert_to_vector<int, size_t>(order.data(), mklDims.size()));
     auto innerBlks = clonedDesc.get_inner_blks();
     auto innerIdxs = clonedDesc.get_inner_idxs();
-    std::vector<int> innerBlksInt(innerBlks.begin(), innerBlks.end());
-    std::vector<int> innerIdxsInt(innerIdxs.begin(), innerIdxs.end());
+    std::vector<int> innerBlksInt(convert_to_vector<int>(innerBlks.data(), innerBlks.size()));
+    std::vector<int> innerIdxsInt(convert_to_vector<int>(innerIdxs.data(), innerIdxs.size()));
 
     auto retCode = dnnl::impl::fill_blocked(*clonedDesc.get(), perm, innerBlksInt, innerIdxsInt);
     OPENVINO_ASSERT(retCode == dnnl::impl::status::success,
@@ -497,7 +497,7 @@ MemoryDescPtr DnnlBlockedMemoryDesc::cloneWithNewDimsImp(const VectorDims& dims)
                     "Can't clone desc if new dims are undefined");
 
     // TODO [DS]: add stride recalculation for strided blobs
-    for (int i = strides.size() - 2; i >= 0; i--) {
+    for (auto i = static_cast<int>(strides.size() - 2); i >= 0; i--) {
         if (strides[i] == Shape::UNDEFINED_DIM) {
             break;
         }

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,
-                size_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,
-                        size_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,
-                size_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,
-                        size_t thread_num = 0);
+                        int thread_num = 0);
 }  // namespace ov::intel_cpu