Apply suggestions from code review

liubo-intel · liubo-intel · commit 319c4b159ffa · 2025-03-13T15:17:22.000+08:00
diff --git a/src/inference/dev_api/openvino/runtime/system_conf.hpp b/src/inference/dev_api/openvino/runtime/system_conf.hpp
@@ -111,13 +111,6 @@ OPENVINO_RUNTIME_API bool with_cpu_x86_avx2();
  */
 OPENVINO_RUNTIME_API bool with_cpu_x86_avx2_vnni();
 
-/**
- * @brief      Checks whether CPU supports AVX2_VNNI_2 capability
- * @ingroup    ov_dev_api_system_conf
- * @return     `True` is AVX2_VNNI_2 instructions are available, `false` otherwise
- */
-OPENVINO_RUNTIME_API bool with_cpu_x86_avx2_vnni_2();
-
 /**
  * @brief      Checks whether CPU supports AVX 512 capability
  * @ingroup    ov_dev_api_system_conf
@@ -142,17 +135,10 @@ OPENVINO_RUNTIME_API bool with_cpu_x86_avx512_core_vnni();
 /**
  * @brief      Checks whether CPU supports BFloat16 capability
  * @ingroup    ov_dev_api_system_conf
- * @return     `True` is tAVX512_BF16 or AVX2_VNNI_2 instructions are available, `false` otherwise
+ * @return     `True` is tAVX512_BF16 instructions are available, `false` otherwise
  */
 OPENVINO_RUNTIME_API bool with_cpu_x86_bfloat16();
 
-/**
- * @brief      Checks whether CPU supports Float16 capability
- * @ingroup    ov_dev_api_system_conf
- * @return     `True` is tAVX512_FP16 or AVX2_VNNI_2 instructions are available, `false` otherwise
- */
-OPENVINO_RUNTIME_API bool with_cpu_x86_float16();
-
 /**
  * @brief      Checks whether CPU supports fp16 capability
  * @ingroup    ov_dev_api_system_conf
diff --git a/src/inference/src/system_conf.cpp b/src/inference/src/system_conf.cpp
@@ -75,11 +75,6 @@ bool with_cpu_x86_avx2_vnni() {
     return get_cpu_info().has(Xbyak::util::Cpu::tAVX2 | Xbyak::util::Cpu::tAVX_VNNI);
 }
 
-bool with_cpu_x86_avx2_vnni_2() {
-    return with_cpu_x86_avx2_vnni() && get_cpu_info().has(Xbyak::util::Cpu::tAVX_VNNI_INT8) &&
-           get_cpu_info().has(Xbyak::util::Cpu::tAVX_NE_CONVERT);
-}
-
 bool with_cpu_x86_avx512f() {
     return get_cpu_info().has(Xbyak::util::Cpu::tAVX512F);
 }
@@ -93,17 +88,13 @@ bool with_cpu_x86_avx512_core_vnni() {
 }
 
 bool with_cpu_x86_bfloat16() {
-    return get_cpu_info().has(Xbyak::util::Cpu::tAVX512_BF16) || with_cpu_x86_avx2_vnni_2();
+    return get_cpu_info().has(Xbyak::util::Cpu::tAVX512_BF16);
 }
 
 bool with_cpu_x86_avx512_core_fp16() {
     return get_cpu_info().has(Xbyak::util::Cpu::tAVX512_FP16);
 }
 
-bool with_cpu_x86_float16() {
-    return with_cpu_x86_avx512_core_fp16() || with_cpu_x86_avx2_vnni_2();
-}
-
 bool with_cpu_x86_avx512_core_amx_int8() {
     return get_cpu_info().has(Xbyak::util::Cpu::tAMX_INT8);
 }
@@ -142,9 +133,6 @@ bool with_cpu_x86_avx2() {
 bool with_cpu_x86_avx2_vnni() {
     return false;
 }
-bool with_cpu_x86_avx2_vnni_2() {
-    return false;
-}
 bool with_cpu_x86_avx512f() {
     return false;
 }
@@ -160,9 +148,6 @@ bool with_cpu_x86_bfloat16() {
 bool with_cpu_x86_avx512_core_fp16() {
     return false;
 }
-bool with_cpu_x86_float16() {
-    return false;
-}
 bool with_cpu_x86_avx512_core_amx_int8() {
     return false;
 }
diff --git a/src/plugins/intel_cpu/src/nodes/paged_attn.cpp b/src/plugins/intel_cpu/src/nodes/paged_attn.cpp
@@ -276,7 +276,7 @@ bool PagedAttention::isSupportedOperation(const std::shared_ptr<const ov::Node>&
 ov::element::Type PagedAttention::getRuntimePrecision() const {
     auto rtPrecision = getOriginalInputPrecisionAtPort(0);
     // bf16 should be enabled only when platform supports
-    if (rtPrecision == ov::element::bf16 && ov::with_cpu_x86_bfloat16() && !ov::with_cpu_x86_avx2_vnni_2()) {
+    if (rtPrecision == ov::element::bf16 && ov::with_cpu_x86_bfloat16()) {
         rtPrecision = ov::element::bf16;
     } else if (rtPrecision == ov::element::f16 && ov::with_cpu_x86_avx512_core_fp16()) {
         rtPrecision = ov::element::f16;
diff --git a/src/plugins/intel_cpu/src/nodes/scaled_attn.cpp b/src/plugins/intel_cpu/src/nodes/scaled_attn.cpp
@@ -1238,7 +1238,7 @@ void ScaledDotProductAttention::createPrimitive() {
         std::shared_ptr<Executor> executor = nullptr;
 #ifdef OPENVINO_ARCH_X86_64
         if (rtPrecision == ov::element::bf16) {
-            if (ov::with_cpu_x86_bfloat16() && !ov::with_cpu_x86_avx2_vnni_2()) {
+            if (ov::with_cpu_x86_bfloat16()) {
                 executor = std::make_shared<AttentionExecutor<KT_ONEDNN, ov::bfloat16>>(context,
                                                                                         m_key_quant_param.groupSize,
                                                                                         m_value_quant_param.groupSize,
@@ -2082,7 +2082,7 @@ const ScaledDotProductAttention::SDPAQuantParam& ScaledDotProductAttention::getV
 ov::element::Type ScaledDotProductAttention::getRuntimePrecision() const {
     auto rtPrecision = getOriginalInputPrecisionAtPort(0);
     // bf16 should be enabled only when platform supports
-    if (rtPrecision == ov::element::bf16 && ov::with_cpu_x86_bfloat16()) {
+    if (rtPrecision == ov::element::bf16 && (ov::with_cpu_x86_bfloat16() || mayiuse(cpu_isa_t::avx2_vnni_2))) {
         rtPrecision = ov::element::bf16;
     } else if (rtPrecision == ov::element::f16 && ov::intel_cpu::hasHardwareSupport(ov::element::f16)) {
         rtPrecision = ov::element::f16;
diff --git a/src/plugins/intel_cpu/src/nodes/topk.cpp b/src/plugins/intel_cpu/src/nodes/topk.cpp
@@ -1986,9 +1986,6 @@ void TopK::initSupportedPrimitiveDescriptors() {
                                                            ov::element::u8};
 
     ov::element::Type dataPrecision = getOriginalOutputPrecisionAtPort(TOPK_DATA);
-    if (dataPrecision == ov::element::bf16 && !hasHardwareSupport(ov::element::bf16)) {
-        THROW_CPU_NODE_ERR("gets incorrect isa for BF16!");
-    }
     bool precisionSupported = std::find(std::begin(supportedPrecision), std::end(supportedPrecision), dataPrecision) !=
                               std::end(supportedPrecision);
     // BF16 is not supported for AVX2_VNNI_2 platforms
diff --git a/src/plugins/intel_cpu/tests/functional/custom/behavior/ov_plugin/properties.cpp b/src/plugins/intel_cpu/tests/functional/custom/behavior/ov_plugin/properties.cpp
@@ -156,8 +156,7 @@ TEST_F(OVClassConfigTestCPU, smoke_PluginSetConfigStreamsNum) {
 #if defined(OPENVINO_ARCH_ARM) || defined(OPENVINO_ARCH_ARM64)
     const auto expected_precision_for_performance_mode = ov::intel_cpu::hasHardwareSupport(ov::element::f16) ? ov::element::f16 : ov::element::f32;
 #else
-const auto expected_precision_for_performance_mode =
-    (ov::with_cpu_x86_bfloat16() && !ov::with_cpu_x86_avx2_vnni_2()) ? ov::element::bf16 : ov::element::f32;
+    const auto expected_precision_for_performance_mode = ov::with_cpu_x86_bfloat16() ? ov::element::bf16 : ov::element::f32;
 #endif
 
 TEST_F(OVClassConfigTestCPU, smoke_PluginSetConfigHintInferencePrecision) {
diff --git a/src/plugins/intel_cpu/tests/functional/custom/single_layer_tests/classes/random_uniform.cpp b/src/plugins/intel_cpu/tests/functional/custom/single_layer_tests/classes/random_uniform.cpp
@@ -79,7 +79,7 @@ void RandomUniformLayerTestCPU::SetUp() {
             updateSelectedType(getPrimitiveType(), ElementType::f32, configuration);
         }
     } else if (output_prc == ElementType::bf16) {
-        if (ov::with_cpu_x86_bfloat16() && !ov::with_cpu_x86_avx2_vnni_2()) {
+        if (ov::with_cpu_x86_bfloat16()) {
             updateSelectedType(getPrimitiveType(), ElementType::bf16, configuration);
         } else {
             updateSelectedType("ref_any", ElementType::bf16, configuration);
diff --git a/src/plugins/intel_cpu/tests/functional/custom/single_layer_tests/classes/scaled_attn.cpp b/src/plugins/intel_cpu/tests/functional/custom/single_layer_tests/classes/scaled_attn.cpp
@@ -59,7 +59,12 @@ void ScaledAttnLayerCPUTest::SetUp() {
     }
 
     if (inType == ElementType::bf16) {
-        rel_threshold = 2e-2f;
+        // Issue: 163144
+        if (with_cpu_x86_avx2_vnni_2()) {
+            rel_threshold = 0.2f;
+        } else {
+            rel_threshold = 2e-2f;
+        }
     }
     selectedType = makeSelectedTypeStr(selectedType, inType);
     init_input_shapes(inputShapes);
@@ -133,7 +138,7 @@ TEST_P(ScaledAttnLayerCPUTest, CompareWithRefs) {
     bool has_scale;
     std::string targetDevice;
     std::tie(inType, inputShapes, is_causal, has_attn, has_scale, targetDevice, cpuParams) = this->GetParam();
-    if (inType == ElementType::bf16 && !ov::with_cpu_x86_bfloat16())
+    if (inType == ElementType::bf16 && !ov::with_cpu_x86_bfloat16() && !with_cpu_x86_avx2_vnni_2())
         GTEST_SKIP();
     run();
     CheckPluginRelatedResults(compiledModel, "ScaledAttn");
diff --git a/src/plugins/intel_cpu/tests/functional/custom/single_layer_tests/group_convolution.cpp b/src/plugins/intel_cpu/tests/functional/custom/single_layer_tests/group_convolution.cpp
@@ -275,7 +275,7 @@ std::vector<groupConvLayerCPUTestParamsSet> filterParamsSetForDevice(
         auto additionalConfig = std::get<configIndex>(param);
         if (additionalConfig.count(ov::hint::inference_precision.name()) &&
             ov::element::bf16 == additionalConfig[ov::hint::inference_precision.name()].as<ov::element::Type>() &&
-            (!ov::with_cpu_x86_bfloat16() || ov::with_cpu_x86_avx2_vnni_2())) {
+            !ov::with_cpu_x86_bfloat16()) {
             continue;
         }
         resParamsSet.push_back(param);
diff --git a/src/plugins/intel_cpu/tests/functional/custom/single_layer_tests/instances/x64/matmul.cpp b/src/plugins/intel_cpu/tests/functional/custom/single_layer_tests/instances/x64/matmul.cpp
@@ -157,7 +157,7 @@ std::vector<ov::AnyMap> filterAdditionalConfig_Brgemm() {
 #else
     std::vector<ov::AnyMap> additionalConfig = {{}};
 #endif
-    if (with_cpu_x86_bfloat16()) {
+    if (with_cpu_x86_bfloat16() || with_cpu_x86_avx2_vnni_2()) {
         additionalConfig.push_back({ov::hint::inference_precision(ov::element::bf16)});
     }
 
diff --git a/src/plugins/intel_cpu/tests/functional/custom/single_layer_tests/normalize.cpp b/src/plugins/intel_cpu/tests/functional/custom/single_layer_tests/normalize.cpp
@@ -65,7 +65,7 @@ class NormalizeL2LayerCPUTest : public testing::WithParamInterface<NormalizeL2La
             selectedType = getPrimitiveType();
         }
         // BF16 is not supported for NormalizeL2 on AVX2_VNNI_2 platforms
-        if (ov::with_cpu_x86_avx2_vnni_2() && inType == ElementType::bf16) {
+        if (with_cpu_x86_avx2_vnni_2() && inType == ElementType::bf16) {
             selectedType = makeSelectedTypeStr("unknown", ElementType::f32);
         } else {
             selectedType = makeSelectedTypeStr("unknown", inType);
diff --git a/src/plugins/intel_cpu/tests/functional/custom/single_layer_tests/roi_pooling.cpp b/src/plugins/intel_cpu/tests/functional/custom/single_layer_tests/roi_pooling.cpp
@@ -195,7 +195,7 @@ class ROIPoolingCPULayerTest : public testing::WithParamInterface<ROIPoolingCPUT
         }
         selectedType.push_back('_');
         // BF16 is not supported for ROIPooling on AVX2_VNNI_2 platforms
-        if (ov::with_cpu_x86_avx2_vnni_2() && netPrecision == ElementType::bf16) {
+        if (with_cpu_x86_avx2_vnni_2() && netPrecision == ElementType::bf16) {
             selectedType += ov::element::f32.to_string();
         } else {
             selectedType += netPrecision.to_string();
diff --git a/src/plugins/intel_cpu/tests/functional/custom/single_layer_tests/topk.cpp b/src/plugins/intel_cpu/tests/functional/custom/single_layer_tests/topk.cpp
@@ -103,7 +103,7 @@ class TopKLayerCPUTest : public testing::WithParamInterface<TopKLayerCPUTestPara
         configuration.insert(additionalConfig.begin(), additionalConfig.end());
 
         // BF16 is not supported for TopK on AVX2_VNNI_2 platforms
-        if (ov::with_cpu_x86_avx2_vnni_2() && netPrecision == ElementType::bf16) {
+        if (with_cpu_x86_avx2_vnni_2() && netPrecision == ElementType::bf16) {
             selectedType = makeSelectedTypeStr(getPrimitiveType(), ElementType::f32);
         } else {
             selectedType = makeSelectedTypeStr(getPrimitiveType(), netPrecision);
diff --git a/src/plugins/intel_cpu/tests/functional/custom/subgraph_tests/src/x64/interaction.cpp b/src/plugins/intel_cpu/tests/functional/custom/subgraph_tests/src/x64/interaction.cpp
@@ -149,7 +149,7 @@ class IntertactionCPUTest : public testing::WithParamInterface<InteractionLayerC
         ElementType inType;
         InputShape inputShape;
         std::tie(inType, inputShape) = this->GetParam();
-        bool with_bf16 = ov::with_cpu_x86_bfloat16();
+        bool with_bf16 = ov::with_cpu_x86_bfloat16() || with_cpu_x86_avx2_vnni_2();
         if (with_bf16 && (inType == ov::element::bf16 || inType == ov::element::i32)) {
             selectedType = makeSelectedTypeStr("ref_any", ov::element::bf16);
         } else {
diff --git a/src/plugins/intel_cpu/tests/functional/shared_tests_instances/skip_tests_config.cpp b/src/plugins/intel_cpu/tests/functional/shared_tests_instances/skip_tests_config.cpp
@@ -9,10 +9,11 @@
 #if defined(OPENVINO_ARCH_RISCV64)
 #   include "nodes/kernels/riscv64/cpu_isa_traits.hpp"
 #endif
-
 #include <string>
 #include <vector>
 
+#include "../tests/functional/utils/cpu_test_utils.hpp"
+
 std::vector<std::string> disabledTestPatterns() {
     std::vector<std::string> retVector{
         // TODO: Issue 31841
@@ -579,7 +580,7 @@ std::vector<std::string> disabledTestPatterns() {
         // TODO: Issue 92895
         // on platforms which do not support AMX, we are disabling I8 input tests
         retVector.emplace_back(R"(smoke_LPT/FakeQuantizeWithNotOptimalTransformation.CompareWithRefImpl.*CPU.*i8.*)");
-    if ((!ov::with_cpu_x86_avx512_core_amx_bf16() && !ov::with_cpu_x86_bfloat16()) || ov::with_cpu_x86_avx2_vnni_2()) {
+    if (!ov::with_cpu_x86_avx512_core_amx_bf16() && !ov::with_cpu_x86_bfloat16()) {
         // ignored for not supported bf16 platforms
         retVector.emplace_back(R"(.*smoke_Snippets_EnforcePrecision_bf16.*)");
         retVector.emplace_back(R"(.*smoke_Snippets_MHAWOTransposeEnforceBF16.*)");
@@ -638,7 +639,7 @@ std::vector<std::string> disabledTestPatterns() {
         retVector.emplace_back(R"(.*smoke_Deconv_(2|3)D_NSPC_INT8_AMX/DeconvolutionLayerCPUTest.*)");
     }
 
-    if (ov::with_cpu_x86_float16()) {
+    if (ov::with_cpu_x86_avx512_core_fp16() || CPUTestUtils::with_cpu_x86_avx2_vnni_2()) {
         // Issue: 143852
         retVector.emplace_back(R"(smoke_ConvertRangeSubgraphCPUTest/ConvertRangeSubgraphCPUTest\.CompareWithRefs.*Prc=f16.*)");
         retVector.emplace_back(R"((smoke|nightly)_FC_3D_FP16/.*_Fused=Multiply\(PerChannel\).*)");
@@ -649,7 +650,7 @@ std::vector<std::string> disabledTestPatterns() {
         retVector.emplace_back(R"(smoke_Conv_Sum_Broadcast_FP16/ConvSumInPlaceTest.*Relu\.Multiply\(PerChannel\)\.Add\(PerChannel\).*)");
     }
 
-    if (ov::with_cpu_x86_avx2_vnni_2()) {
+    if (CPUTestUtils::with_cpu_x86_avx2_vnni_2()) {
         // jit_gemm_BF16 kernels are not supported for conv,inner_product,matmul on avx2_vnni_2 platforms
         retVector.emplace_back(R"(smoke_Conv_.*D_GEMM_BF16.*)");
         retVector.emplace_back(
@@ -658,9 +659,6 @@ std::vector<std::string> disabledTestPatterns() {
         // Issue: 163147
         retVector.emplace_back(
             R"(smoke_CompareWithRefs_4D.*[Ff]using.*EltwiseLayerCPUTest\.CompareWithRefs.*INFERENCE_PRECISION_HINT=f16.*enforceSnippets=1.*)");
-        // Issue: 163144
-        retVector.emplace_back(
-            R"(smoke_ScaledAttn_CPU/ScaledAttnLayerCPUTest.CompareWithRefs/netPRC=bf16.*_TS=\(2\.8\.16\.32\)_\(2\.8\.16\.32\)_\(2\.8\.16\.32\)_\(1\.8\.48\.32\)_\(1\.8\.48\.32\)_\(1\.8\.48\.32\)_\(16\.48\)_\(16\.1\)_\(1\.48\).*)");
     }
 
     return retVector;
diff --git a/src/plugins/intel_cpu/tests/functional/shared_tests_instances/snippets/fully_connected.cpp b/src/plugins/intel_cpu/tests/functional/shared_tests_instances/snippets/fully_connected.cpp
@@ -31,8 +31,7 @@ static inline std::vector<std::vector<element::Type>> precisions(bool only_fp32
         auto quant = quantized_precisions();
         std::copy(quant.begin(), quant.end(), std::back_inserter(prc));
         // In Snippets MatMul BF16 is supported only on bf16/AMX platforms
-        if ((ov::with_cpu_x86_bfloat16() && !ov::with_cpu_x86_avx2_vnni_2()) ||
-            ov::with_cpu_x86_avx512_core_amx_bf16()) {
+        if (ov::with_cpu_x86_bfloat16() || ov::with_cpu_x86_avx512_core_amx_bf16()) {
             prc.emplace_back(std::vector<element::Type>{element::bf16, element::bf16});
         }
     }
diff --git a/src/plugins/intel_cpu/tests/functional/shared_tests_instances/snippets/transpose_matmul.cpp b/src/plugins/intel_cpu/tests/functional/shared_tests_instances/snippets/transpose_matmul.cpp
@@ -179,8 +179,7 @@ static inline std::vector<std::vector<element::Type>> precisions(bool only_fp32
             prc.emplace_back(std::vector<element::Type>{element::u8, element::i8});
         }
         // In Snippets MatMul BF16 is supported only on bf16/AMX platforms
-        if ((ov::with_cpu_x86_bfloat16() && !ov::with_cpu_x86_avx2_vnni_2()) ||
-            ov::with_cpu_x86_avx512_core_amx_bf16()) {
+        if (ov::with_cpu_x86_bfloat16() || ov::with_cpu_x86_avx512_core_amx_bf16()) {
             prc.emplace_back(std::vector<element::Type>{element::bf16, element::bf16});
         }
     }
diff --git a/src/plugins/intel_cpu/tests/functional/shared_tests_instances/snippets/utils.hpp b/src/plugins/intel_cpu/tests/functional/shared_tests_instances/snippets/utils.hpp
@@ -13,7 +13,7 @@ namespace snippets {
 #define SNIPPETS_TESTS_STATIC_SHAPES(...) static_shapes_to_test_representation(std::vector<std::vector<ov::Shape>>{__VA_ARGS__})
 
 static inline bool is_bf16_supported_by_brgemm() {
-    return (ov::with_cpu_x86_bfloat16() && !ov::with_cpu_x86_avx2_vnni_2()) || ov::with_cpu_x86_avx512_core_amx_bf16();
+    return ov::with_cpu_x86_bfloat16() || ov::with_cpu_x86_avx512_core_amx_bf16();
 }
 
 static inline bool is_fp16_supported_by_brgemm() {
diff --git a/src/plugins/intel_cpu/tests/functional/utils/cpu_test_utils.cpp b/src/plugins/intel_cpu/tests/functional/utils/cpu_test_utils.cpp
@@ -12,6 +12,9 @@
 #include "transformations/rt_info/primitives_priority_attribute.hpp"
 #include "utils/general_utils.h"
 #include "utils/rt_info/memory_formats_attribute.hpp"
+#if defined(OPENVINO_ARCH_X86) || defined(OPENVINO_ARCH_X86_64)
+#    include <xbyak/xbyak_util.h>
+#endif
 
 namespace CPUTestUtils {
 const char* CPUTestsBase::any_type = "any_type";
@@ -45,6 +48,22 @@ const char* CPUTestsBase::cpu_fmt2str(cpu_memory_format_t v) {
     return "undef";
 }
 
+#if defined(OPENVINO_ARCH_X86) || defined(OPENVINO_ARCH_X86_64)
+static Xbyak::util::Cpu& get_cpu_info() {
+    static Xbyak::util::Cpu cpu;
+    return cpu;
+}
+bool with_cpu_x86_avx2_vnni_2() {
+    return get_cpu_info().has(Xbyak::util::Cpu::tAVX2 | Xbyak::util::Cpu::tAVX_VNNI) &&
+           get_cpu_info().has(Xbyak::util::Cpu::tAVX_VNNI_INT8) &&
+           get_cpu_info().has(Xbyak::util::Cpu::tAVX_NE_CONVERT);
+}
+#else  // OPENVINO_ARCH_X86 || OPENVINO_ARCH_X86_64
+bool with_cpu_x86_avx2_vnni_2() {
+    return false;
+}
+#endif  // OPENVINO_ARCH_X86 || OPENVINO_ARCH_X86_64
+
 cpu_memory_format_t CPUTestsBase::cpu_str2fmt(const char* str) {
 #define CASE(_fmt)                                              \
     do {                                                        \
@@ -473,8 +492,9 @@ CPUTestsBase::deduce_expected_precision(const ov::element::Type& opPrecision,
         auto inferencePrecisionConfig = it->second.as<ov::element::Type>();
         inferencePrecisionSetExplicitly = true;
         if ((inferencePrecisionConfig == ov::element::bf16 &&
-             (ov::with_cpu_x86_avx512_core() || ov::with_cpu_x86_avx2_vnni_2())) ||
-            (inferencePrecisionConfig == ov::element::f16 && ov::with_cpu_x86_float16()) ||
+             (ov::with_cpu_x86_avx512_core() || with_cpu_x86_avx2_vnni_2())) ||
+            (inferencePrecisionConfig == ov::element::f16 &&
+             (ov::with_cpu_x86_avx512_core_fp16() || with_cpu_x86_avx2_vnni_2())) ||
             (inferencePrecisionConfig == ov::element::f32) || (inferencePrecisionConfig == ov::element::dynamic)) {
             inferencePrecision = inferencePrecisionConfig;
         }
@@ -484,7 +504,7 @@ CPUTestsBase::deduce_expected_precision(const ov::element::Type& opPrecision,
         const auto& configIt = configuration.find(executionModeKey);
         if (configIt != configuration.end() && configIt->second.as<ov::hint::ExecutionMode>() == ov::hint::ExecutionMode::PERFORMANCE) {
             inferencePrecision = ov::element::f32;
-            if (ov::with_cpu_x86_bfloat16() && !ov::with_cpu_x86_avx2_vnni_2()) {
+            if (ov::with_cpu_x86_bfloat16()) {
                 inferencePrecision = ov::element::bf16;
             }
         } else {
@@ -496,7 +516,7 @@ CPUTestsBase::deduce_expected_precision(const ov::element::Type& opPrecision,
     // enforceInferPrecision stage
     if (inferencePrecision == ov::element::bf16) {
         deducedType =
-            (ov::with_cpu_x86_avx512_core() || ov::with_cpu_x86_avx2_vnni_2()) ? ov::element::bf16 : ov::element::f32;
+            (ov::with_cpu_x86_avx512_core() || with_cpu_x86_avx2_vnni_2()) ? ov::element::bf16 : ov::element::f32;
     }
 
     // ngraph transform pipeline stage
@@ -507,7 +527,7 @@ CPUTestsBase::deduce_expected_precision(const ov::element::Type& opPrecision,
     }
     if (deducedType == ov::element::bf16) {
         deducedType =
-            (ov::with_cpu_x86_avx512_core() || ov::with_cpu_x86_avx2_vnni_2()) ? ov::element::bf16 : ov::element::f32;
+            (ov::with_cpu_x86_avx512_core() || with_cpu_x86_avx2_vnni_2()) ? ov::element::bf16 : ov::element::f32;
     } else if (deducedType == ov::element::f16) {
         if (inferencePrecision != ov::element::f16 && inferencePrecision != ov::element::dynamic) {
             deducedType = ov::element::f32;
diff --git a/src/plugins/intel_cpu/tests/functional/utils/cpu_test_utils.hpp b/src/plugins/intel_cpu/tests/functional/utils/cpu_test_utils.hpp
@@ -113,7 +113,7 @@ inline std::string nodeType2str(nodeType nt) {
         return "GroupConvolutionBackpropData";
     throw std::runtime_error("Undefined node type to convert to string!");
 }
-
+bool with_cpu_x86_avx2_vnni_2();
 class CPUTestsBase {
 public:
     typedef std::map<std::string, ov::Any> CPUInfo;
diff --git a/src/plugins/intel_cpu/tests/unit/brgemm_executor_test.cpp b/src/plugins/intel_cpu/tests/unit/brgemm_executor_test.cpp
@@ -70,7 +70,7 @@ void run_test(ov::element::Type rtPrec) {
 
 TEST_P(BrgemmKernelTest, simpleGemmTest) {
     ov::element::Type rtPrec = this->GetParam();
-    if (rtPrec == ov::element::bf16 && (!ov::with_cpu_x86_bfloat16() || ov::with_cpu_x86_avx2_vnni_2()))
+    if (rtPrec == ov::element::bf16 && !ov::with_cpu_x86_bfloat16())
         GTEST_SKIP();
     if (rtPrec == ov::element::f32 && !ov::with_cpu_x86_avx512_core())
         GTEST_SKIP();
diff --git a/src/tests/functional/shared_test_classes/src/base/ov_subgraph.cpp b/src/tests/functional/shared_test_classes/src/base/ov_subgraph.cpp

Original file line number	Diff line number	Diff line change
`@@ -75,11 +75,6 @@ bool with_cpu_x86_avx2_vnni() {`
`75`	`75`	`return get_cpu_info().has(Xbyak::util::Cpu::tAVX2 \| Xbyak::util::Cpu::tAVX_VNNI);`
`76`	`76`	`}`
`77`	`77`
`78`		`-bool with_cpu_x86_avx2_vnni_2() {`
`79`		`- return with_cpu_x86_avx2_vnni() && get_cpu_info().has(Xbyak::util::Cpu::tAVX_VNNI_INT8) &&`
`80`		`- get_cpu_info().has(Xbyak::util::Cpu::tAVX_NE_CONVERT);`
`81`		`-}`
`82`		`-`
`83`	`78`	`bool with_cpu_x86_avx512f() {`
`84`	`79`	`return get_cpu_info().has(Xbyak::util::Cpu::tAVX512F);`
`85`	`80`	`}`
`@@ -93,17 +88,13 @@ bool with_cpu_x86_avx512_core_vnni() {`
`93`	`88`	`}`
`94`	`89`
`95`	`90`	`bool with_cpu_x86_bfloat16() {`
`96`		`- return get_cpu_info().has(Xbyak::util::Cpu::tAVX512_BF16) \|\| with_cpu_x86_avx2_vnni_2();`
	`91`	`+ return get_cpu_info().has(Xbyak::util::Cpu::tAVX512_BF16);`
`97`	`92`	`}`
`98`	`93`
`99`	`94`	`bool with_cpu_x86_avx512_core_fp16() {`
`100`	`95`	`return get_cpu_info().has(Xbyak::util::Cpu::tAVX512_FP16);`
`101`	`96`	`}`
`102`	`97`
`103`		`-bool with_cpu_x86_float16() {`
`104`		`- return with_cpu_x86_avx512_core_fp16() \|\| with_cpu_x86_avx2_vnni_2();`
`105`		`-}`
`106`		`-`
`107`	`98`	`bool with_cpu_x86_avx512_core_amx_int8() {`
`108`	`99`	`return get_cpu_info().has(Xbyak::util::Cpu::tAMX_INT8);`
`109`	`100`	`}`
`@@ -142,9 +133,6 @@ bool with_cpu_x86_avx2() {`
`142`	`133`	`bool with_cpu_x86_avx2_vnni() {`
`143`	`134`	`return false;`
`144`	`135`	`}`
`145`		`-bool with_cpu_x86_avx2_vnni_2() {`
`146`		`- return false;`
`147`		`-}`
`148`	`136`	`bool with_cpu_x86_avx512f() {`
`149`	`137`	`return false;`
`150`	`138`	`}`
`@@ -160,9 +148,6 @@ bool with_cpu_x86_bfloat16() {`
`160`	`148`	`bool with_cpu_x86_avx512_core_fp16() {`
`161`	`149`	`return false;`
`162`	`150`	`}`
`163`		`-bool with_cpu_x86_float16() {`
`164`		`- return false;`
`165`		`-}`
`166`	`151`	`bool with_cpu_x86_avx512_core_amx_int8() {`
`167`	`152`	`return false;`
`168`	`153`	`}`
Original file line number	Diff line number	Diff line change
`@@ -79,7 +79,7 @@ void RandomUniformLayerTestCPU::SetUp() {`
`79`	`79`	`updateSelectedType(getPrimitiveType(), ElementType::f32, configuration);`
`80`	`80`	`}`
`81`	`81`	`} else if (output_prc == ElementType::bf16) {`
`82`		`- if (ov::with_cpu_x86_bfloat16() && !ov::with_cpu_x86_avx2_vnni_2()) {`
	`82`	`+ if (ov::with_cpu_x86_bfloat16()) {`
`83`	`83`	`updateSelectedType(getPrimitiveType(), ElementType::bf16, configuration);`
`84`	`84`	`} else {`
`85`	`85`	`updateSelectedType("ref_any", ElementType::bf16, configuration);`
Original file line number	Diff line number	Diff line change
`@@ -275,7 +275,7 @@ std::vector<groupConvLayerCPUTestParamsSet> filterParamsSetForDevice(`
`275`	`275`	`auto additionalConfig = std::get<configIndex>(param);`
`276`	`276`	`if (additionalConfig.count(ov::hint::inference_precision.name()) &&`
`277`	`277`	`ov::element::bf16 == additionalConfig[ov::hint::inference_precision.name()].as<ov::element::Type>() &&`
`278`		`- (!ov::with_cpu_x86_bfloat16() \|\| ov::with_cpu_x86_avx2_vnni_2())) {`
	`278`	`+ !ov::with_cpu_x86_bfloat16()) {`
`279`	`279`	`continue;`
`280`	`280`	`}`
`281`	`281`	`resParamsSet.push_back(param);`
Original file line number	Diff line number	Diff line change
`@@ -157,7 +157,7 @@ std::vector<ov::AnyMap> filterAdditionalConfig_Brgemm() {`
`157`	`157`	`#else`
`158`	`158`	`std::vector<ov::AnyMap> additionalConfig = {{}};`
`159`	`159`	`#endif`
`160`		`- if (with_cpu_x86_bfloat16()) {`
	`160`	`+ if (with_cpu_x86_bfloat16() \|\| with_cpu_x86_avx2_vnni_2()) {`
`161`	`161`	`additionalConfig.push_back({ov::hint::inference_precision(ov::element::bf16)});`
`162`	`162`	`}`
`163`	`163`