[CPU] Add test case for precision fp16

src/inference/dev_api/openvino/runtime/system_conf.hpp

@@ -146,6 +146,13 @@ OPENVINO_RUNTIME_API bool with_cpu_x86_avx512_core_amx_int8();
  */
 OPENVINO_RUNTIME_API bool with_cpu_x86_avx512_core_amx_bf16();
 
+/**
+ * @brief      Checks whether CPU supports AMX fp16 capability
+ * @ingroup    ov_dev_api_system_conf
+ * @return     `True` is tAMX_FP16 instructions are available, `false` otherwise
+ */
+OPENVINO_RUNTIME_API bool with_cpu_x86_avx512_core_amx_fp16();
+
 /**
  * @brief      Checks whether CPU supports AMX capability
  * @ingroup    ov_dev_api_system_conf

src/inference/src/system_conf.cpp

@@ -92,6 +92,10 @@ bool with_cpu_x86_avx512_core_amx_bf16() {
     return get_cpu_info().has(Xbyak::util::Cpu::tAMX_BF16);
 }
 
+bool with_cpu_x86_avx512_core_amx_fp16() {
+    return get_cpu_info().has(Xbyak::util::Cpu::tAMX_FP16);
+}
+
 bool with_cpu_x86_avx512_core_amx() {
     return with_cpu_x86_avx512_core_amx_int8() || with_cpu_x86_avx512_core_amx_bf16();
 }
@@ -131,6 +135,9 @@ bool with_cpu_x86_avx512_core_amx_int8() {
 bool with_cpu_x86_avx512_core_amx_bf16() {
     return false;
 }
+bool with_cpu_x86_avx512_core_amx_fp16() {
+    return false;
+}
 bool with_cpu_x86_avx512_core_amx() {
     return false;
 }

src/plugins/intel_cpu/src/graph.cpp

@@ -1631,7 +1631,7 @@ void Graph::EnforceInferencePrecision() {
 
         for (size_t i = 0; i < node->getOriginalInputsNumber(); i++) {
             auto keepOriginalInputPrecisionAtPort = [](const NodePtr& node, const size_t inPort) {
-                // keep non-float precisions
+                // keep non-float32 precisions
                 if (node->getOriginalInputPrecisionAtPort(inPort) != ov::element::f32)
                     return true;
 
@@ -1672,7 +1672,7 @@ void Graph::EnforceInferencePrecision() {
         }
 
         for (size_t i = 0; i < node->getOriginalOutputsNumber(); i++) {
-            // keep non-float precisions
+            // keep non-float32 precisions
             if (node->getOriginalOutputPrecisionAtPort(i) != ov::element::f32)
                 continue;
 

src/plugins/intel_cpu/tests/functional/CMakeLists.txt

@@ -46,7 +46,13 @@ endif()
 if(NOT X86_64)
     list(APPEND EXCLUDED_SOURCE_PATHS
          ${CMAKE_CURRENT_SOURCE_DIR}/custom/single_layer_tests/instances/x64
-         ${CMAKE_CURRENT_SOURCE_DIR}/custom/subgraph_tests/src/x64)
+         ${CMAKE_CURRENT_SOURCE_DIR}/custom/subgraph_tests/src/x64
+         ${CMAKE_CURRENT_SOURCE_DIR}/utils/x64)
+endif()
+
+if(NOT RISCV64)
+    list(APPEND EXCLUDED_SOURCE_PATHS
+         ${CMAKE_CURRENT_SOURCE_DIR}/utils/RISCV64)
 endif()
 
 ov_add_test_target(

src/plugins/intel_cpu/tests/functional/custom/single_layer_tests/classes/convolution.cpp

@@ -165,6 +165,9 @@ void ConvolutionLayerCPUTest::SetUp() {
         rel_threshold = 1e-2f;
         if (selectedType == "jit_gemm_BF16")
             rel_threshold = 0.05f;
+    } else if (it != configuration.end() && it->second.as<ov::element::Type>() == ov::element::f16) {
+            selectedType +=  "_FP16";
+            rel_threshold = 0.00125f;
     } else {
         selectedType = makeSelectedTypeStr(selectedType, netType);
     }

src/plugins/intel_cpu/tests/functional/custom/single_layer_tests/classes/matmul.cpp

@@ -120,11 +120,13 @@ void MatMulLayerCPUTest::SetUp() {
     auto it = additionalConfig.find(ov::hint::inference_precision.name());
     if (it != additionalConfig.end() && it->second.as<ov::element::Type>() == ov::element::bf16)
         inType = outType = netType = ElementType::bf16;
+    else if (it != additionalConfig.end() && it->second.as<ov::element::Type>() == ov::element::f16)
+        inType = outType = netType = ElementType::f16;
     else
         inType = outType = netType;
 
     cpuNodeType = nodeType == MatMulNodeType::MatMul ? "MatMul" : "FullyConnected";
-    selectedType = makeSelectedTypeStr(selectedType, outType);
+    selectedType = makeSelectedTypeStr(selectedType, get_default_imp_precision_type(outType, configuration));
 
     ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(netType, inShapeA)};
 
@@ -151,6 +153,7 @@ void MatMulLayerCPUTest::SetUp() {
 }
 
 TEST_P(MatMulLayerCPUTest, CompareWithRefs) {
+    SKIP_IF_CURRENT_TEST_IS_DISABLED();
     // due to disabled BF16 fakequant fusing: src/plugins/intel_cpu/src/graph_optimizer.cpp#L755, skip this case
     if (inType == ElementType::bf16) {
         if (cpuNodeType == "FullyConnected") {

src/plugins/intel_cpu/tests/functional/custom/single_layer_tests/classes/pooling.cpp

@@ -19,7 +19,8 @@ std::string PoolingLayerCPUTest::getTestCaseName(const testing::TestParamInfo<po
     bool isInt8;
     CPUSpecificParams cpuParams;
     fusingSpecificParams fusingParams;
-    std::tie(basicParamsSet, inputShapes, inPrc, isInt8, cpuParams, fusingParams) = obj.param;
+    ov::AnyMap additionalConfig;
+    std::tie(basicParamsSet, inputShapes, inPrc, isInt8, cpuParams, fusingParams, additionalConfig) = obj.param;
 
     utils::PoolingTypes poolType;
     std::vector<size_t> kernel, stride;
@@ -53,6 +54,12 @@ std::string PoolingLayerCPUTest::getTestCaseName(const testing::TestParamInfo<po
     results << "Rounding=" << roundingType << "_";
     results << "AutoPad=" << padType << "_";
     results << "INT8=" << isInt8 << "_";
+    if (!additionalConfig.empty()) {
+        results << "_PluginConf";
+            for (auto& item : additionalConfig) {
+                results << "_" << item.first << "=" << item.second.as<std::string>();
+            }
+        }
 
     results << CPUTestsBase::getTestCaseName(cpuParams);
     results << CpuTestWithFusing::getTestCaseName(fusingParams);
@@ -68,7 +75,9 @@ void PoolingLayerCPUTest::SetUp() {
     bool isInt8;
     CPUSpecificParams cpuParams;
     fusingSpecificParams fusingParams;
-    std::tie(basicParamsSet, inputShapes, inPrc, isInt8, cpuParams, fusingParams) = this->GetParam();
+    ov::AnyMap additionalConfig;
+    std::tie(basicParamsSet, inputShapes, inPrc, isInt8, cpuParams, fusingParams, additionalConfig) = this->GetParam();
+    configuration.insert(additionalConfig.begin(), additionalConfig.end());
 
     utils::PoolingTypes poolType;
     std::vector<size_t> kernel, stride;
@@ -87,7 +96,7 @@ void PoolingLayerCPUTest::SetUp() {
     if (isInt8)
         selectedType = selectedType + "_I8";
     else
-        selectedType = makeSelectedTypeStr(selectedType, inPrc);
+        selectedType = makeSelectedTypeStr(selectedType, get_default_imp_precision_type(inPrc, configuration));
 
     init_input_shapes({inputShapes});
 
@@ -118,7 +127,8 @@ std::string MaxPoolingV8LayerCPUTest::getTestCaseName(
     InputShape inputShapes;
     ElementType inPrc;
     CPUSpecificParams cpuParams;
-    std::tie(basicParamsSet, inputShapes, inPrc, cpuParams) = obj.param;
+    ov::AnyMap additionalConfig;
+    std::tie(basicParamsSet, inputShapes, inPrc, cpuParams, additionalConfig) = obj.param;
 
     std::vector<size_t> kernel, stride, dilation;
     std::vector<size_t> padBegin, padEnd;
@@ -145,6 +155,12 @@ std::string MaxPoolingV8LayerCPUTest::getTestCaseName(
     results << "PE" << ov::test::utils::vec2str(padEnd) << "_";
     results << "Rounding=" << roundingType << "_";
     results << "AutoPad=" << padType << "_";
+    if (!additionalConfig.empty()) {
+        results << "_PluginConf";
+        for (auto& item : additionalConfig) {
+            results << "_" << item.first << "=" << item.second.as<std::string>();
+        }
+    }
 
     results << CPUTestsBase::getTestCaseName(cpuParams);
     return results.str();
@@ -157,7 +173,9 @@ void MaxPoolingV8LayerCPUTest::SetUp() {
     InputShape inputShapes;
     ElementType inPrc;
     CPUSpecificParams cpuParams;
-    std::tie(basicParamsSet, inputShapes, inPrc, cpuParams) = this->GetParam();
+    ov::AnyMap additionalConfig;
+    std::tie(basicParamsSet, inputShapes, inPrc, cpuParams, additionalConfig) = this->GetParam();
+    configuration.insert(additionalConfig.begin(), additionalConfig.end());
 
     std::vector<size_t> kernel, stride, dilation;
     std::vector<size_t> padBegin, padEnd;
@@ -171,7 +189,7 @@ void MaxPoolingV8LayerCPUTest::SetUp() {
     if (selectedType.empty()) {
         selectedType = getPrimitiveType();
     }
-    selectedType = makeSelectedTypeStr(selectedType, inPrc);
+    selectedType = makeSelectedTypeStr(selectedType, get_default_imp_precision_type(inPrc, configuration));
 
     init_input_shapes({inputShapes});
 
@@ -458,4 +476,4 @@ const std::vector<InputShape>& inputShapes4D_Large() {
 
 }  // namespace Pooling
 }  // namespace test
-}  // namespace ov
+}  // namespace ov

src/plugins/intel_cpu/tests/functional/custom/single_layer_tests/classes/pooling.hpp

@@ -19,12 +19,15 @@ using poolLayerCpuTestParamsSet = std::tuple<poolSpecificParams,
                                              ElementType,
                                              bool,
                                              CPUSpecificParams,
-                                             fusingSpecificParams>;
+                                             fusingSpecificParams,
+                                             ov::AnyMap>;
+
 
 using maxPoolV8LayerCpuTestParamsSet = std::tuple<maxPoolV8SpecificParams,
         InputShape,
         ElementType,
-        CPUSpecificParams>;
+        CPUSpecificParams,
+        ov::AnyMap>;
 
 class PoolingLayerCPUTest : public testing::WithParamInterface<poolLayerCpuTestParamsSet>,
                             virtual public SubgraphBaseTest, public CpuTestWithFusing {

src/plugins/intel_cpu/tests/functional/custom/single_layer_tests/classes/softmax.cpp

@@ -16,7 +16,8 @@ std::string SoftMaxLayerCPUTest::getTestCaseName(const testing::TestParamInfo<so
     ElementType inType;
     SoftMaxConfig config;
     std::string targetDevice;
-    std::tie(inType, config, targetDevice, cpuParams) = obj.param;
+    ov::AnyMap additionalConfig;
+    std::tie(inType, config, targetDevice, cpuParams, additionalConfig) = obj.param;
 
     std::ostringstream result;
     result << "netPRC=" << inType << "_";
@@ -30,6 +31,12 @@ std::string SoftMaxLayerCPUTest::getTestCaseName(const testing::TestParamInfo<so
     result << "axis=" << config.axis << "_";
     result << "trgDev=" << targetDevice;
     result << CPUTestsBase::getTestCaseName(cpuParams);
+    if (!additionalConfig.empty()) {
+        result << "_PluginConf";
+        for (auto& item : additionalConfig) {
+            result << "_" << item.first << "=" << item.second.as<std::string>();
+        }
+    }
 
     return result.str();
 }
@@ -38,7 +45,9 @@ void SoftMaxLayerCPUTest::SetUp() {
     ElementType inType;
     SoftMaxConfig config;
     CPUSpecificParams cpuParams;
-    std::tie(inType, config, targetDevice, cpuParams) = this->GetParam();
+    ov::AnyMap additionalConfig;
+    std::tie(inType, config, targetDevice, cpuParams, additionalConfig) = this->GetParam();
+    configuration.insert(additionalConfig.begin(), additionalConfig.end());
 
     std::tie(inFmts, outFmts, priority, selectedType) = cpuParams;
     if (selectedType.empty()) {
@@ -48,7 +57,7 @@ void SoftMaxLayerCPUTest::SetUp() {
     if (inType == ElementType::bf16) {
         rel_threshold = 2e-2f;
     }
-    selectedType = makeSelectedTypeStr(selectedType, inType);
+    selectedType = makeSelectedTypeStr(selectedType, get_default_imp_precision_type(inType, configuration));
     init_input_shapes({config.inputShape});
     ov::ParameterVector params;
     for (auto&& shape : inputDynamicShapes)

src/plugins/intel_cpu/tests/functional/custom/single_layer_tests/classes/softmax.hpp

@@ -18,7 +18,8 @@ struct SoftMaxConfig {
 typedef std::tuple<ElementType,    // netPrecision
                    SoftMaxConfig,  // softmaxTestConfig
                    std::string,    // targetDevice
-                   CPUSpecificParams>
+                   CPUSpecificParams,
+                   ov::AnyMap> //device_config
     softmaxCPUTestParams;
 
 class SoftMaxLayerCPUTest : public testing::WithParamInterface<softmaxCPUTestParams>,